Java集合

文章目录

集合
- 为什么要使用集合
- 1.集合的架构
- 2.Collection接口
- 2.1遍历集合中数据
- 3.List接口
- 4.ArrayList类
- 5.LinkedList
- 6.LinkedList和ArrayList的区别
7.Set集合
- 7.1HashSet
- 7.2TreeSet
- 7.3TreeSet泛型存的是对象
8.Map集合
- 遍历map集合方式

集合为什么要使用集合

1.集合和数组是一样的都是用来存储数据的

2.数组封装的方法是比较少，Java给封装集合，这个集合是一个类库。只需要实例化对象，调用方法。

1.集合的架构

从上往下写

2.Collection接口

学习这个接口方法

Collection方法

增:
boolean add(E e);添加一个数据到集合中，采用的尾插法
boolean addAll(Collection c);将一个集合添加到另外一个集合中
    
删:
boolean remove(Object obj);删除指定的元素
boolean removeAll(Collection c);删除一个两个集合中交集数据
       
查:
int size(); 集合中元素的个数
void clear();清空集合中所有元素    
Object[] toArray(); 将集合转为数组
boolean contains(Object obj);判断在集合中是否包含你传入的这个元素
boolean containsAll(Collection c);判段一个集合是否是另外一个集合的子集合
boolean isEmpty();判断此集合是否为空集合  里面没有数据

2.1遍历集合中数据

所有集合遍历的三种方式

1.使用for循环先转为数组然后再for循环遍历

	  //泛型必须写类
        Collection collection=new ArrayList<>();
         collection.add("123");
         collection.add("123");
        //1.for
        //将集合转为数组
        Object[] objects = collection.toArray();
        for (int i = 0; i 
            System.out.println(objects[i]);
        }

2.使用增强for循环（常用）

语法格式:

for (集合数组的元素类型  临时变量: 集合或者数组) {

}

        Collection collection=new ArrayList<>();
        collection.add("123");
        collection.add("456");
        //2.foreach
        for (String str : collection) {
            System.out.println(str);
        }

3.迭代器

  //3.迭代器
        Collection collection=new ArrayList<>();
        Iterator iterator = collection.iterator();
        //hasNext()方法 在集合中 第一个元素的前面有一个光标cursor 判断下一个元素是否有值
        //next()方法 是输出当前光标下一个元素  再把光标移到输出的数据上面
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

3.List接口

1.List是Collection子类

2.子类不单重写了父类的方法而且还有自己的独有的方法

3.List是有序的，可重复的

增:
boolean add(int index, E e); 在指定的位置的下面添加一个元素
boolean addAll(int index, Collection e);

List list = new ArrayList<>();
       //  添加元素
       list.add("张三");
       list.add("李四");
       list.add("王五");
       System.out.println(list);//[张三, 李四, 王五]
       //根据索引添加字符串
       list.add(2, "张三");
       System.out.println(list);//[张三, 李四, 张三, 王五]

方法过多不做演示 List独有的方法

List接口下面独有的方法:
特征:有序 可以重复的
增:
boolean add(int index, E e);  在指定的位置的下面添加一个元素
boolean addAll(int index, Collection e);

删：
collection里面通过元素删除的 List里面又增加了方法通过索引删除的
E  remove(int index); 通过下标删除指定的元素，返回值是被删除的元素

改:
E set(int index, E e); 通过指定的元素替换指定下标的元素，返回值是被替换的元素

查:
E get(int index);  通过下标获取当前下标的元素
int indexOf(Object o);通过元素获取指定的元素下标
int lastIndexOf(Object o);指定的元素最后一次出现的位置
List subList(int startIndex, int endIndex);  截取集合  要头不要尾

4.ArrayList类

1.ArrayList底层是数组，默认的容量只能存10个值，会扩容的，扩1.5倍。

2.特征: 查询快增删慢。

3.是List的实现类继承了List和Collection的所有方法

        ArrayList list = new ArrayList<>();
        //如果使用多态，父类引用不能调用子类的独有的方法
        list.add("张三");
        list.add("李四");
        System.out.println(list);
        //foreach
        for (String string : list) {
            System.out.println(string);//张三 李四
        }

5.LinkedList

LinkedList 也是List实现类双向链表
队列: 先进先出栈:先进后出
特征: 查询慢，插入删除快

public class Demo2 {
    public static void main(String[] args) {
        LinkedList strings = new LinkedList<>();
        strings.add("张三");
        strings.add("李四");
        System.out.println(strings);
        strings.addFirst("王八");
        strings.addLast("海龟");
        System.out.println(strings);
        for (String string : strings) {
            System.out.println(string);
            //[王八, 张三, 李四, 海龟]
        }
    }
}

6.LinkedList和ArrayList的区别

ArrayList底层是数组这个数组的初始化容量是１０
会自动扩容，每次扩容１.５倍
ArrayList有一些特征:
	查询快  增删慢。
	查询快:底层是索引，好比书的目录，直接查询到值的，时间复杂度是1
	增删慢:增加数据或者删除有可能牵涉到数组的扩容问题，数组的复制问题，还有可能牵涉到数组的前移和后移。（for） 时间复杂度是n
	但是开发中查询居多。增删少。所以开发用ArrayList
LinkedList有一些特征:
	查询慢  增删快
	查询慢:底层使用的是二分法查找的算法（今天百度Java 二分查找算法）时间复杂度是log以2为底n的对数
	增删快:直接找到被添加或者被删除元素的前置节点和后置节点进行添加和删除 时间复杂度是1

7.Set集合

父类：Collection

存储数据特征: 无序的不可重复的。

HashSet：底层是依靠hash值进行存储的，如果hash值一样的话，存不到集合中。

TreeSet：底层是二叉树，对存入的数据进行自然排序。

7.1HashSet

HashSet是Set集合的实现类，是hash值进行存储

public class Demo1 {
    public static void main(String[] args) {
        //set集合是无序的  不可重复的
        Set set = new HashSet<>();
        set.add("b");
        set.add("a");
        set.add("c");
        set.add("a");
        System.out.println(set);//按照hash值进行存储
        Set set1 = new HashSet<>();
        set1.add(34);
        set1.add(23);
        set1.add(89);
        System.out.println(set1);
        //增强for循环
        for (Integer integer : set1) {
            System.out.println(integer);
        }
        //迭代器
       Iterator iterator = set1.iterator();
        while (iterator.hasNext()) {
        System.out.println(iterator.next());
        }
        //是可以使用Collection下面的方法的
    }
}

HashSet泛型存入的是对象

package com.kz.a_hashset;

import java.util.HashSet;
import java.util.Objects;
import java.util.TreeSet;

public class Demo02 {
    public static void main(String[] args) {
        HashSet set=new HashSet();
        Person person1=new Person("kz",20);
        Person person3=new Person("kz",20);
        Person person2=new Person("kz",201);
        set.add(person1);
        set.add(person2);
        set.add(person3);
        System.out.println(set);
    }

}
class Person  {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

}

总结:hashset存对象的时候，一定要重写equals和hashCode方法当对象的内容一样的话，可以不存入set集合中

7.2TreeSet

可以保证数据的唯一性，存储也是无序

同时对存入的数据，默认的进行排序。底层是二叉树

TreeSet泛型存入的是对象

存对象的时候需要实现一个Comparable这个接口否则会报类型转换异常

抽象方法
int compareTo(T o)

7.3TreeSet泛型存的是对象

案例扩展:

使用TreeSet 集合保存Employee对象，比较两个属性 int age int weight。

需求:先按照年龄进行升序排，然后如果年龄相等的话，体重升序排

class Employee implements Comparable{
    int age;
    int weight;

    public Employee(int age, int weight) {
        this.age = age;
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "age=" + age +
                ", weight=" + weight +
                '}';
    }

    @Override
    public int compareTo(Employee o) {
        //先按照年龄排 然后年龄相等的  按照体重排
        int num = this.age - o.age;
        if (num == 0) {
            int num1 = this.weight - o.weight;

            return num1;
        }
        return num;
    }
}
public class Demo3 {
    public static void main(String[] args) {
        Employee employee1 = new Employee(23, 78);
        Employee employee2 = new Employee(20, 68);


        TreeSet emps = new TreeSet<>();
        emps.add(employee1);
        emps.add(employee2);
        System.out.println(emps);

    }
}

关于TreeSet在存数据的时候，会有一个排序问题，使用Comparable这个接口进行排序

这是一种方式，咱们还有一种方式可以进行比较排序叫比较器的写法

需要使用一个接口 Comparator 重写compare(Emp o1, Emp o2)

总结:

ArrayList:不需要注意任何事项，只是单纯存取数据而已。  数据可以重复  有序的  开发
LinkedList:不需要注意任何事项，只是单纯存取数据而已。  数据可以重复  有序的
HashSet: 数据不可重复的  无序的。   
		 不可重复很关键，底层hash值进行存储的。
		 注意点:当存储对象的时候，关注的是对象的内容。如果对象内容一样，不一定能存到	
		 hashSet集合中 切记重写equals和hashCode方法即可
TreeSet:数据也是不可重复， 但是TreeSet 会进行自然排序，要让实体类去实现Comparable即可或者使用比较器 Comparator

8.Map集合

双边队列

Map K：key 键 V：value 值键对值

2个实现类

HashMap
TreeMap

Map maps = new HashMap<>();
        maps.put("007", "周星驰");

map集合中常用的方法

增:
	V put(K key, V value);  添加键值对的数据到map集合中
	void putAll(Map k, Map v); 将一个map集合存入到另外一个集合中。但是 键和值的数据类型要保持一致
删:
	V remove(K key);  通过键删除值，返回值被删除的值
改:
	V put(K key, V value);  当键有值的话，如果再写相同的键的话，会覆盖  不就是修改
查:
	int size();  查看键值对的个数
	boolean isEmpty();是否为空
	boolean containsKey(Object key);是否包含这个键
	boolean containsValue(Object value);是否包含这个值
	
	V get(K key);通过键获取值
	重要方法：
	Set keySet();
		获取map集合中的键，返回值是Set集合
	Collection values();	
		获取map集合中所有的value的值  返回的是Collection对象
	Set>  entrySet();
	将map集合中的键值对封装到一个Set集合中

开发中一般使用集合类型:
	List<类的泛型> list = new ArrayList<>();
	Map map = new HashMap<>();

遍历map集合方式

package com.kz.a_map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo01 {
    public static void main(String[] args) {
        HashMap map=new HashMap<>();
        map.put("001", "a");
        map.put("002", "a");
        map.put("003", "a");
        //遍历map
        for (String s : map.keySet()) {
            //取k值
            System.out.println(s);
        }
            //取V
        for (String value : map.values()) {
            System.out.println(value);
        }
        //第二中方式 将K,V全部添加进set集合中
        Set> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println(entry);
            //只取值
            System.out.println(entry.getValue());
        }
    }
}

Java集合

Java相关栏目本月热门文章