集合01.

Collections类

•  java.utils.Collections是集合工具类，用来对集合进行操作

常用方法：

• public static void shuffle(List<?> list) :打乱集合顺序
• public static<T> void sort(List<T> list):将集合中元素按照默认规则排序
• public static<T> void sort(List<T> list,Comparator<?super t> com):将集合中的元素按照指定规则排序

 代码演示：

public class Test1 {
    public static void main(String[] args) {
        method01();

    }

    public static void method01(){
        List<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(50);
        list.add(1000);
        System.out.println("打乱顺序之前:"+list);
        Collections.shuffle(list);
        System.out.println("打乱顺序之后:"+list);
        Collections.sort(list);
        System.out.println(list);
            Collections.sort(list, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2-o1;
                }
            });

        System.out.println(list);
        
    }

}

---

可变参数

可变参数的使用

        在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化。

格式：

修饰符  返回值类型  方法名(参数类型...形参名){    }

代码： 

public class Test01{
    public static void main(String [] args){
            //可变参数语法
        int [] arr ={10,20,30,40,50,60};
            //调用method1方法
        method1(10,20,30,40,50);
            //调用method2方法
        method2(arr);
        method2(10,20,30,40,50,60);
            //调用method3方法
        method3(arr);
        method3(10,20,30,40,50,60);
            //调用method4方法
        method4(10,"jack",rose);
        
    
       


    }

   
    
    public static void method4(int num,String ...str){

    
      }
    
        //定义一个方法，可以接收5个int类型的参数
    public static void method3(int [] arr){
        for(int i:arr){
            System.out.println(i);
        }        
             System.out.println(arr[0]);

    }
        //定义一个方法，可以接收5个int类型的参数
    public static void method2(int ...num){
            for(int i:num){
                System.out.println(i);    
        }
            System.out.pirntln(num[0]);
     
        }
        
    
        //定义一个方法，可以接收5个int类型的参数
     public static void method1(int num1,int num2,int num3,int num4,int num5){


    }




}

---

注意事项：

1. 一个方法只能有一个可变参数
2. 如果方法中有多个参数，可变参数要放到最后

应用场景：Collections

在Collections中也提供了添加一些元素方法： 

        public static<T> boolean addAll(Collection<T> c,T...elements):往集合中添加一些元素

代码演示： 

public class CollectionsDemo {
 public static void main(String[] args) {
 ArrayList<Integer> list = new
ArrayList<Integer>();
 //原来写法
 //list.add(12);
 //list.add(14);
 //list.add(15);
 //list.add(1000);
 //采⽤⼯具类 完成 往集合中添加元素 
 Collections.addAll(list, 5, 222, 1，2);
 System.out.println(list);
}

---

Set集合

Set接口：也称Set集合，但凡是实现了Set接口的类都叫做Set集合

        特点：元素无索引，元素存取无序，元素不可重复（唯一）

实现类：

•  HashSet集合：元素无索引，元素存取无序，元素不可重复（唯一）
• LinkedHashSet集合：元素无索，引元素有序，元素不可重复(唯一)
• TreeSet集合：元素无索引，元素存取无序，元素不可重复(唯一)，元素可排序

注意：

1. Set集合并没有特有的功能，都是使用Collection父接口中的方法
2. Set集合元素无索引，所以遍历方式只能是：迭代器，增强for循环 

HashSet集合  

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无须的(即存取顺序不能保证不一致)

代码：

public class Test {
 public static void main(String[] args) {
 /*
 HashSet集合的特点:
 HashSet集合(类): 存储数据的数据结构,哈希
表结构,元素唯⼀,元素⽆索引,元素存取⽆序
⼩结
略
知识点--HashSet集合存储数据的
结构（哈希表）
 */
 // 创建⼀个HashSet集合,限制集合中元素的类型为
String类型
 HashSet<String> set = new HashSet<>();
 // 往集合中添加元素
 set.add("nba");
 set.add("cba");
 set.add("bac");
 set.add("abc");
 set.add("nba");
 System.out.println(set);// [cba, abc,bac, nba]
 }
}

---

 HashSet集合保证元素唯⼀的原理:底层是哈希表结构,哈希表保证元素唯⼀依赖于hashCode()和equals⽅法();

1. 当HashSet集合存储元素的时候,就会调⽤该元素的hashCode()⽅法计算哈希值
2. 判断该哈希值位置上 , 是否有相同哈希值的元苏
3. 如果该哈希值位置上没有相同哈希值的元素 , 那么就直接存储
4. 如果该哈希值位置上有相同哈希值的元素 , 那么就产⽣了哈希冲突
5. 如果产⽣了哈希冲突 , 就得调⽤该元素的 equals () ⽅法与该哈希值位置上的所有元素进⾏⼀⼀⽐较

    

如果该哈希值位置上有任意⼀个元素与该元素相等,那么就不存储

如果该哈希值位置上所有的元素与该元素不相等那么就直接存储

HashSet存储自定义类型元素

给 HashSet 中存放⾃定义类型元素时，需要重写对象中的 hashCode和 equals ⽅法，建⽴⾃⼰的⽐较⽅式，才能保证 HashSet集合中的对象唯⼀ .

import java.util.HashMap;
import java.util.Objects;

public class Test3 {
    private String name;
    private int age;

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

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

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

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

    public static void main(String[] args) {
         //创建多个Test对象
        Test3 test1 = new Test3("张三",18);
        Test3 test2 = new Test3("李四",12);
        Test3 test3= new Test3("王五",18);
        Test3 test4= new Test3("张三",18);
           // 创建HashSet集合对象,限制集合中元素的类型为Person
            set.add(Test1);
            set.add(Test2);
            set.add(Test3);
            set.add(Test4);
   // 遍历打印集合中的元素
             for (Person p : set) {
             System.out.println(p);
                 }
         System.out.println(p1.hashCode());
         System.out.println(p2.hashCode());
         System.out.println(p3.hashCode());
         System.out.println(p4.hashCode());

    }
}

---

LinkedHashSet

•  LinkedHashSet保证元素怎么存怎么取，即存取有序
• HashSet保证元素唯⼀，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？
• 在 HashSet 下⾯有⼀个⼦类 java.util.LinkedHashSet，它是链表和哈希表组合的⼀个数据存储结构。

public class LinkedHashSetDemo {

 public static void main(String[] args) {
 Set<String> set = new LinkedHashSet<String>
();
 set.add("bbb");
 set.add("aaa");
 set.add("abc");
 set.add("bbc");
 Iterator<String> it = set.iterator();
 while (it.hasNext()) {
 System.out.println(it.next());
 }
 } }
结果：
 bbb
 aaa
 abc
 bbc

---

 TreeSet集合

 TreeSet集合是Set接⼝的⼀个实现类,底层依赖于TreeMap,是⼀种基于红⿊树的实现,其特点为：

1. 元素唯一
2. 元素没有索引
3. 使用元素的自然顺序对元素进行排序，或者根据创建TreeSet时提供的Comparator比较器进行排序具体取决于使用的构造方法：

public TreeSet(): 根据其元素的自然排序进行排序

public TreeSet(Comparator<E> comparator):根据指定的比较器进行排序 

 

public static void main(String[] args) {
 //⽆参构造,默认使⽤元素的⾃然顺序进⾏排序
 TreeSet<Integer> set = new TreeSet<Integer>
();
 set.add(20);
 set.add(18);
 set.add(23);
 set.add(22);
 set.add(17);
 set.add(24);
 set.add(19);
 System.out.println(set);
}
控制台的输出结果为: [17, 18, 19, 20, 22, 23, 24]

---

比较器排序：

public static void main(String[] args) {
 //有参构造,传⼊⽐较器,使⽤⽐较器对元素进⾏排序
 TreeSet<Integer> set = new TreeSet<Integer> (new Comparator<Integer>() {
 @Override
⼩结
略
第三章 Map集合
知识点-- Map概述
 public int compare(Integer o1, Integer
o2) {
 //元素前 - 元素后 : 升序
 //元素后 - 元素前 : 降序
 return o2 - o1;
 }
 });
 set.add(20);
 set.add(18);
 set.add(23);
 set.add(22);
 set.add(17);
 set.add(24);
 set.add(19);
 System.out.println(set);
}
控制台的输出结果为: [24, 23, 22, 20, 19, 18, 17]