Collection与Collections

我不是女神ヾ 2023-10-07 18:32 13阅读 0赞

>     *1,什么是集合(Collection)
>     *      集合是一个大小可变的容器
>     *      容器中的每个数据称为一个元素，数据==元素
>     *      集合的特点是，类型可以不确定，大小不固定，集合有很多种类，不同集合特点和使用场景*        不同
>     *      数组：类型和长度一旦定义出就固定了
>     * 2,集合作用：
>     *      在开发过程中，很多时候元素的个数是不确定的
>     *      而且经常要进行元素的增删改查错做，集合都是非常合适的
>     *      在开发中集合用的更多
>     *    java中集合的代表：Collection 是java中的集合的祖宗类
>     *                          Collection<>(接口)
>     *                          /               \
>     *                  Set<E>(接口)              List<E>(接口)
>     *                    /     \                   /        \
>     *         HashSet<E>(实现类)  TreeSet<>      ArrayList<E> LinkedList<E> Vector
>     *                  /            (实现类)           (实现类)       (实现类)
>     *           LinkedHashSet<>(实现类)
>     *
>     *3,集合的特点
>     *      Set系列集合：添加的元素是无序的，不重复，无索引
>     *          --HashSet:无序的，不重复，无索引
>     *          --LinkedHashSet:有序，不重复，无索引
>     *          --TreeSet:按照大小默认升序，不重复，无索引
>     *      List系列集合：添加的元素是有序，不重复，无索引
>     *          --ArrayList：
>     *          --LinkedList：
>     *      Collection是集合的祖宗类，Collection集合的功能是一切集合都可以直接使用的
>     *4,功能：
>     *      public boolean add():  把给定的对象添加到当前集合中
>     *      public void clear():    清空集合中的所有元素
>     *      public boolean remove():   把给定的对象在当前集合中删除//list如果重复默认删除**        第一个
>     *      public boolean isEmpty():  判断当前集合是否为空
>     *      public int size():     返回集合中元素的个数
>     *      public Object[] toArray():  把集合中的元素，存储到数组中
>     *5,Collection集合遍历的三种方式
>     *      >迭代器
>     *      >foreach(增强for循环)
>     *      >jdk1.8开始之后的Lambda表达式
>     
>     *   a,迭代器遍历集合
>     *      public Iterator iterator();获取集合对应的迭代器，u哦你过来遍历集合中的元素
>     *      E next():获取下一个元件的值
>     *      Boolean hasNext()：判断是否有下一个元素，有就返回true
>     *     流程：
>     *      1，Iterator<String> it = list.iterator();
>     *      2定义一个while循环，通过it.hasNext()询问是否有下一个元素，有就通过it.next()去**        除下一个元素
>     *   b,foreach(增强for循环)
>     *      foreach是一种遍历形式，可以遍历集合或者数组
>     *      foreach遍历集合实际上是迭代器遍历的减缓写法
>     *      foreach关键是记住格式
>     *          for(被便利集合或者数组中的元素的类型 变量名称 ： 被遍历集合或者数组){
>     *
>     *          }
>     *      缺点：foreach遍历无法知道遍历到了哪个元素，因为没有索引
>     *

public class DemoCollection {
        public static void main(String[] args) {
            //HashSet:无序的，不重复，无索引
            Collection<String> string = new HashSet<>();
            string.add("Mysql");
            string.add("Mysql");
            string.add("Java");
            string.add("Java");
            System.out.println(string);//[Java, Mysql]
    
            //ArrayList:添加的元素是有序，不重复，无索引
            List<String> list = new ArrayList<>();
            list.add("mysql");
            list.add("mysql");
            list.add("java");
            list.add("java");
            System.out.println(list);//[mysql, mysql, java, java]
        
            Object[] arrs = list.toArray();
            //String[] arr = list.toArray(String::new);方法引用：指定转换的数组类型
            System.out.println("数组"+ Arrays.toString(arrs));
            
            //1，得到集合的迭代器对象
            Iterator<String> it = list.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
            
            //2，foreach
            for (String s : list) {
                System.out.println(s);
            }
            for (Object arr : arrs) {
                System.out.println(arr);
            }
            //3,Lambda
            list.forEach(s -> System.out.println());
            list.forEach(System.out::println);
        }
    }

>     java.utils.Collections：是集合工具类
>     *      并不属于集合，是用来操作集合的工具类
>     * 常用API
>     *      --public static <T> boolean addAll(Collection<? super ?> c,T...elements):给*         集合对象批量添加元素
>     *      --public static void shuffle(List<?> list):打乱集合顺序
>     *      --public static <T> void sort(List<T> list):将集合中的元素按照默认规则排序
>     *          将集合中元素按照默认规则排序
>     *          对于自定义的引用类型的排序直接报错
>     *          不报错，提供比较规则Com[arable
>     *      --public static <T> list,Comparator<? super ?>:将集合中元素按照指定规则排序，*         自带比较器
>     *          将集合中元素按照指定规则排序，自带比较器
>     *          注意：如果类又比较规则，优先使用比较器

public class DemoCollections {
        public static void main(String[] args) {
    
            //1,给集合批量添加元素
            Collection<String> name = new ArrayList<>();
            Collections.addAll(name, "王五", "李四", "赵六","张三");//被添加元素的集合,可变参数
            System.out.println(name);//[王五, 李四, 赵六, 张三]
    
            //2,打乱集合的顺序,只能打乱有序List集合
            List<String> names = new ArrayList<>();
            Collections.addAll(names, "张三", "李四", "王二","麻子");
            Collections.shuffle(names);
            System.out.println(names);//[王二, 李四, 张三, 麻子]
    
            //3，将集合中的元素按照默认规则排序
            ArrayList<Double> scores = new ArrayList<>();
            Collections.addAll(scores, 9.9,1.1,10.1,0.001,0.0001);
            Collections.sort(scores);
            System.out.println(scores);//[1.0E-4, 0.001, 1.1, 9.9, 10.1]
        
            //4,将集合中元素按照指定规则排序，自带比较器
            List<Employee> employees1 = new ArrayList<>();
            //自定义类型排序
            //优先使用方法自带的比较器对象Comparator而不会用类的比较规则
            Employee aa = new Employee("张三", 250, 150);
            Employee bb = new Employee("李四", 50, 140);
            Employee cc = new Employee("王五", 150, 180);
            Employee dd = new Employee("赵六", 520, 10);
            Collections.addAll(employees1, aa,bb,cc,dd);
            Collections.sort(employees1, new Comparator<Employee>() {
                @Override
                public int compare(Employee o1, Employee o2) {
                    //o1比较者，o2被比较者
                    return o1.getWeight() - o2.getWeight();
                }
            });
            System.out.println(employees1);
            //[Orange{name='赵六', sales=520.0, weight=10}, Orange{name='李四', sales=50.0, 
              weight=140}, Orange{name='张三', sales=250.0, weight=150}, Orange{name='王五', 
              sales=150.0, weight=180}]
        }
    }
    
    class Employee implements Comparable<Employee>{
        private String name;
        private double sales;
        private int weight;
        
        public Employee(String name, double sales, int weight) {
            this.name = name;
            this.sales = sales;
            this.weight = weight;
        }
        
        public String getName() {
            return name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        public double getSales() {
            return sales;
        }
        
        public void setSales(double sales) {
            this.sales = sales;
        }
        
        public int getWeight() {
            return weight;
        }
        
        public void setWeight(int weight) {
            this.weight = weight;
        }
        
        @Override
        public String toString() {
            return "Orange{" +
                    "name='" + name + '\'' +
                    ", sales=" + sales +
                    ", weight=" + weight +
                    '}';
        }
        
        //重写比较方法 比较者：this，被比较者：o
        @Override
        public int compareTo(Employee o) {
            return this.weight - o.weight;
        }
    }