Java_集合_16

collection集合

1. 什么是集合?
   集合是一个大小可变的容器。
   容器中的每个数据称为一个元素。数据==元素。
   集合的特点是：类型可以不确定，大小不固定。集合有很多种，不同的集合特点和使用场景不同。
   数组：类型和长度一旦定义出来就都固定了。

2. 集合有啥用？
   在开发中，很多时候元素的个数是不确定的。
   而且经常要进行元素的增删该查操作，集合都是非常合适的。
   开发中集合用的更多!!

3. Java中集合的代表是：Collection.
   Collection集合是Java中集合的祖宗类。
   学习Collection集合的功能，那么一切集合都可以用这些功能！！

4. Collection集合的体系:
   Collection(接口)
   /
   Set(接口) List(接口)
   / \ /
   HashSet(实现类) TreeSet<>(实现类) ArrayList(实现类) LinekdList<>(实现类)
   /
   LinkedHashSet<>(实现类)

5. 集合的特点：
   Set系列集合：添加的元素是无序，不重复，无索引的。
   – HashSet:添加的元素是无序，不重复，无索引的。
   – LinkedHashSet:添加的元素是有序，不重复，无索引的。
   – TreeSet:不重复，无索引，按照大小默认升序排序!!
   List系列集合：添加的元素是有序，可重复，有索引。
   – ArrayList：添加的元素是有序，可重复，有索引。
   – LinekdList：添加的元素是有序，可重复，有索引。

6. 小结：
   Collection是集合的祖宗类，Collection集合的功能是一切集合都可以直接使用的。
   **如果希望元素可以重复，又有索引，查询要快用ArrayList集合。（用的最多）
   **如果希望元素可以重复，又有索引，增删要快要用LinkedList集合。（适合查询元素比较少的情况，经常要首尾操作元素的情况）
   **如果希望增删改查都很快，但是元素不重复以及无序无索引，那么用HashSet集合。
   **如果希望增删改查都很快且有序，但是元素不重复以及无索引，那么用LinkedHashSet集合。

public class CollectionDemo01 {
    public static void main(String[] args) {
        // 多态写法：
        //  HashSet:添加的元素是无序，不重复，无索引的。
        Collection<String> sets = new HashSet<>();
        sets.add("MyBatis");
        sets.add("Java");
        sets.add("Java");
        sets.add("Spring");
        sets.add("MySQL");
        sets.add("MySQL");
        // [Java, MySQL, MyBatis, Spring]
        System.out.println(sets);

        // ArrayList:添加的元素是有序，可重复，有索引。
        Collection<String> lists = new ArrayList<>();
        lists.add("MyBatis");
        lists.add("Java");
        lists.add("Java");
        lists.add("Spring");
        lists.add("MySQL");
        lists.add("MySQL");
        // [MyBatis, Java, Java, Spring, MySQL, MySQL]
        System.out.println(lists);
    }
}

集合常用的API

Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它。
Collection API如下：
- public boolean add(E e)： 把给定的对象添加到当前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素，存储到数组中
小结：
记住以上API。

public class CollectionDemo {
    public static void main(String[] args) {
        // HashSet:添加的元素是无序，不重复，无索引。
        Collection<String> sets = new HashSet<>();
        // 1.添加元素，添加成功返回true.
        System.out.println(sets.add("贾")); // true
        System.out.println(sets.add("贾")); // false
        System.out.println(sets.add("王强")); // true
        sets.add("陈凡");
        System.out.println(sets); // 集合重写了toString()方法，默认打印出内容信息
        // 2.清空集合的元素。
        //sets.clear();
        //System.out.println(sets);

        // 3.判断集合是否为空 是空返回true 反之
        System.out.println(sets.isEmpty()); // false

        // 4.获取集合的大小
        System.out.println(sets.size()); // 3

        // 5.判断集合中是否包含某个元素 。
        System.out.println(sets.contains("贾"));

        // 6.删除某个元素:如果有多个重复元素默认删除前面的第一个！
        sets.remove("陈羽");
        System.out.println(sets);

        // 7.把集合转换成数组
        Object[] arrs = sets.toArray();
        System.out.println("数组："+ Arrays.toString(arrs));

        String[] arrs1 = sets.toArray(String[]::new); // 指定转换的数组类型！
        System.out.println("数组："+ Arrays.toString(arrs1));

        System.out.println("---------------------拓展(集合合并)---------------------------");
        Collection<String> c1 = new ArrayList<>();
        c1.add("李璐");
        c1.add("蓉");

        Collection<String> c2 = new ArrayList<>();
        c2.add("百合");

        c1.addAll(c2); // 把c2集合的元素全部倒入到c1
        System.out.println(c1);
    }
}

迭代器遍历集合

1. 什么是遍历? 为什么开发中要遍历？
   遍历就是一个一个的把容器中的元素访问一遍。
   开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。

2. Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
   Collection集合的遍历方式有三种:
   （1）迭代器。
   （2）foreach(增强for循环)。
   （3）JDK 1.8开始之后的新技术Lambda表达式(了解)

3. 迭代器遍历集合。
   – 方法：
   public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
   E next():获取下一个元素值！
   boolean hasNext():判断是否有下一个元素，有返回true ,反之。
   –流程：
   1.先获取当前集合的迭代器
   Iterator it = lists.iterator();
   2.定义一个while循环，问一次取一次。
   通过it.hasNext()询问是否有下一个元素，有就通过
   it.next()取出下一个元素。

public class CollectionDemo01 {
    public static void main(String[] args){
        Collection<String> str = new ArrayList<>();
        str.add("周芷若");
        str.add("张无忌");
        str.add("赵敏");
        //1.得到迭代器对象。
        Iterator<String> ite = str.iterator();
        System.out.println(ite.next()); //打印周芷若
        System.out.println(ite.next()); //ite游标移到下一个位置 打印张无忌
        System.out.println(ite.next()); //同理
    }

}

利用while取

public class CollectionDemo01 {
    public static void main(String[] args){
        Collection<String> str = new ArrayList<>();
        str.add("周芷若");
        str.add("张无忌");
        str.add("赵敏");
        //1.得到迭代器对象。
        Iterator<String> ite = str.iterator();
        //2.while遍历  hasnext询问是否有下一个元素
        while(ite.hasNext()) System.out.println(ite.next());
    }
}

利用foreach遍历

利用foreach遍历 没有索引！！！只能从头到尾的遍历！

public class CollectionDemo01 {
    public static void main(String[] args){
        Collection<String> str = new ArrayList<>();
        str.add("周芷若");
        str.add("张无忌");
        str.add("赵敏");
        //1.得到迭代器对象。
        Iterator<String> ite = str.iterator();
        //2.foreach遍历
       for(String i : str) System.out.println(ite.next());
    }
}

利用Lambda表达式遍历

public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        //   [赵敏, 小昭, 殷素素, 周芷若]
        //   s
        lists.forEach(s -> {
            System.out.println(s);
        });
//      lists.forEach(s ->  System.out.println(s));
//      lists.forEach(System.out::println);
    }
}

Collections工具类

1. java.utils.Collections:是集合工具类
2. Collections并不属于集合，是用来操作集合的工具类。
3. Collections有几个常用的API:
   public static boolean addAll(Collection<? super T> c, T... elements) 给集合对象批量添加元素！ public static void shuffle(List<?> list) :打乱集合顺序。
   public static void sort(List list):将集合中元素按照默认规则排序。
   public static void sort(List list，Comparator<? super T> ):将集合中元素按照指定规则排序。

public class CollectionsDemo01 {
    public static void main(String[] args) {
        // 1.给集合批量添加元素
        Collection<String> names = new ArrayList<>();
        /**
         * 参数一：被添加元素的集合
         * 参数二：可变参数，一批元素
         */
        Collections.addAll(names,"曹操","贾乃亮","王宝强","陈羽凡");
        System.out.println(names);

        // 2.打乱集合的顺序：public static void shuffle(List<?> list)
        // 注意：只能打乱有序的List集合。
        List<String> newnames = new ArrayList<>();
        Collections.addAll(newnames,"曹操","贾乃亮","王宝强","陈羽凡");
        Collections.shuffle(newnames); // 打乱顺序
        System.out.println(newnames);

        // 3.public static <T> void sort(List<T> list)：给List集合升序排序。
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores, 98.5, 66.5 , 59.5 , 66.5 , 99.5 );
        Collections.sort(scores); // 默认升序排序！
        System.out.println(scores);
    }
}

Collections对List集合自定义类型排序

1. 字符串按照首字符的编号升序排序！

2. 自定义类型的比较方法API:

   • public static void sort(List list):
     将集合中元素按照默认规则排序。
     对于自定义的引用类型的排序人家根本不知道怎么排，直接报错！
     如果希望自定义的引用类型排序不报错，可以给类提供比较规则:Comparable。

   • public static void sort(List list，Comparator<? super T> c):
     将集合中元素按照指定规则排序,自带比较器
     注意：如果类有比较规则，而这里有比较器，优先使用比较器。

public class CollectionsDemo02 {
    public static void main(String[] args) {
        // 自定义类型如何排序！
        List<Orange> oranges = new ArrayList<>();
        Orange o1 = new Orange("红橘子",654.0 ,"贼便宜~");
        Orange o2 = new Orange("黄橘子",454.0 ,"贼便宜~");
        Orange o3 = new Orange("黄橘子",454.0 ,"贼便宜~");
        Orange o4 = new Orange("青橘子",456.0 ,"贼便宜~");
        Collections.addAll(oranges,o1,o2,o3,o4);
        Collections.sort(oranges); // 排序，按照类实现的比较规则进行排序！！
        System.out.println(oranges);


        List<Orange> oranges1 = new ArrayList<>();
        Orange o11 = new Orange("红橘子",654.0 ,"贼便宜~");
        Orange o22 = new Orange("黄橘子",454.0 ,"贼便宜~");
        Orange o33 = new Orange("黄橘子",454.0 ,"贼便宜~");
        Orange o44 = new Orange("青橘子",456.0 ,"贼便宜~");
        Collections.addAll(oranges1,o11,o22,o33,o44);
        // 优先用方法自带的比较器对象Comparator而不会用类的比较规则！！
        Collections.sort(oranges1, new Comparator<Orange>() {
            @Override
            public int compare(Orange o1, Orange o2) {
                if(o1.getWeight() > o2.getWeight()) return -1;
                if(o1.getWeight() < o2.getWeight()) return 1;
                return 0;
            }
        });
        System.out.println(oranges1);
    }
}