Java集合

1.List集合：

​ 有序，可重复的集合

1. List 代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引

2. List 允许使用重复元素，可以通过索引来访问指定位置的集合元素。

3. List 默认按元素的添加顺序设置元素的索引。

4. List 集合里添加了一些根据索引来操作集合元素的方法

​ 1.1List接口的使用：

public static void main(String[] args) {
        //1，创建
        List list =new ArrayList<>();
        //添加元素
        list.add("独孤求败");
        list.add("东方不败");
        list.add("令狐冲");
        //指定位置添加
        list.add(1,"岳不群");
        System.out.println(""+list.size());
        System.out.println(list);
      //移除元素  list.remove(1);
      //  System.out.println(list);

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
           // listIterator.next();
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());

        }

    }

public static void main(String[] args) {
        List list =new ArrayList();
        //添加数组数据（自动装箱）
        list.add(1);
        list.add(2);
        list.add(4);
        list.add(3);
        list.add(5);
        System.out.println("元素个数="+list.size());
        System.out.println(list.toString());
        //删除
        //list.remove(0);
       // list.remove((Object) 5);
       // System.out.println("元素个数="+list.size());
       // System.out.println(list.toString());

        //sublist  返回集合
        List list1 = list.subList(1,3);//含头不含尾
        System.out.println(list1.toString());

    }

​ 1.2 List实现类

1. ​ ArrayList 和 Vector 是 List 接口的两个典型实现：

​ Vector：

• ​ 数组结构实现，查询快 增删慢
• ​ 运行效率低，线程不安全

​ 1.3 ArrayList

• 数组结构实现，查询快，增删慢
• 运行效率低，线程不全

 public static void main(String[] args) {
        ArrayList arr = new ArrayList();
        Student stu1 = new Student("张大大",34);
        Student stu2 = new Student("张三丰",23);
        Student stu3 = new Student("赵三",45);
        Student stu4 = new Student("王三",19);
        //添加学生信息
        arr.add(stu1);
        arr.add(stu2);
        arr.add(stu3);
        arr.add(stu4);
        System.out.println("元素个数："+arr.size());
        System.out.println(arr.toString());
        //删除
       // arr.remove(new Student("张三丰",23));
        System.out.println(arr.size());
        //使用迭代器遍历
        Iterator it=arr.iterator();
        while (it.hasNext()){
            Student stu =(Student) it.next();
            System.out.println(stu.toString());

        }
        System.out.println("-----------------------");
        //列表迭代器
        ListIterator ltor= arr.listIterator();
        while (ltor.hasNext()){
            Student stu = (Student) ltor.next();
            System.out.println(stu.toString());
        }

        System.out.println("-----------------------");
        //逆序
        while (ltor.hasPrevious()){
            Student stu = (Student) ltor.previous();
            System.out.println(stu.toString());
        }
        //判断
        System.out.println(arr.contains(stu2));
        System.out.println(arr.isEmpty());

        //查找
        System.out.println(arr.indexOf(stu2));


    }

​ 1.4linkdList

• 链表结构实现，增删快 查询慢

   public static void main(String[] args) {
          linkedList kedlt = new linkedList();
  
          Student stu1 = new Student("张三丰",23);
          Student stu2 = new Student("赵三",45);
          Student stu3= new Student("王三",19);
          kedlt.add(stu1);
          kedlt.add(stu2);
          kedlt.add(stu3);
  
          System.out.println("元素个数："+kedlt.size());
          System.out.println(kedlt.toString());
  
  
          //删除
         // kedlt.remove(stu1);
         // System.out.println("删除之后的个数"+kedlt.size());
          //kedlt.clear();
  
          System.out.println("使用for --------------------遍历");
          for (int i=0;i< kedlt.size();i++){
              System.out.println(kedlt.get(i));
  
          }
  
          System.out.println("使用增强for --------------------遍历");
          for (Object object:kedlt
               ) {
              Student st =(Student) object;
              System.out.println(st.toString());
          }
  
          System.out.println("使用迭代器 --------------------遍历");
          Iterator it= kedlt.iterator();
         while (it.hasNext()){
             Student s=(Student) it.next();
             System.out.println(s.toString());
         }
  
  
          System.out.println("使用列表迭代器 --------------------遍历");
          ListIterator lit= kedlt.listIterator();
          while (lit.hasNext()){
              Student s1=(Student) lit.next();
              System.out.println(s1.toString());
          }
          //判断
          System.out.println(kedlt.contains(stu1));
          System.out.println(kedlt.isEmpty());
  
          //获取·
          System.out.println(kedlt.indexOf(stu2));
      }
  

  ArrayList和linkdList的区别：

  ArrayList数组结构查询快，增删慢

  linkdList链表结构增删快 查询慢

  泛型：java集合默认是会丢失类型，只要将元素存储的集合中，默认就变成了Object类型

  为了集合能够记住具体的类型，jdk1.5之后提供了泛型功能

  泛型一定定义，那么默认只能存放对应的类型

  泛型在指定类型的时候，不能使用基本类型，必须使用对应的包装类

  泛型的关键字：<>括号

  public static void main(String[] args) {
      Collection collection = new ArrayList();
  
      collection.add(1);
      collection.add(2);
      //collection.add("aa");  //非法，只能存放Integer类型数据
      //collection.add(true);  //非法，只能存放Integer类型数据
  
      // 由于指定了泛型，所以现在取出来的数据 ，也是有对应的类型
      Iterator it = collection.iterator();
      while (it.hasNext()) {
          Integer ele = it.next();
          System.out.println("ele = " + ele);
      }
  
      //增强for
      for (Integer ele : collection) {
          System.out.println("ele = " + ele);
      }
  
  }
  

2.Set集合：

​ 无序、不可重复的集合。

• ​ Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。

• ​ Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals 方法

  hashCode和equals()方法
  • hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
  • 当向 HashSet 集合中存入一个元素时，，，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置
  • 如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

  class Dog {
      private String name;
      private int age;
  
      public Dog() {
      }
  
      public Dog(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      @Override
      public String toString() {
          return "Dog{" +
              "name='" + name + ''' +
              ", age=" + age +
              '}';
      }
  
      @Override
      public boolean equals(Object o) {
          System.out.println("equals:" + this);
          //自动生成
          //if (this == o) return true;
          //if (o == null || getClass() != o.getClass()) return false;
          //Dog dog = (Dog) o;
          // return age == dog.age && Objects.equals(name, dog.name);
  
          //name和age是否相等，如果相等  返回true
          if (this == o) {
              return true;
          }
  
          if (o instanceof Dog) {
              Dog dog = (Dog) o;
              if (this.name.equals(dog.name) && (this.age == dog.age)) {
                  return true;
              }
          }
  
          return false;
      }
  
      @Override
      public int hashCode() {
          //工具类自动生成
          //return Objects.hash(name, age);
  
          //只要name和age一致，返回相同的hashcode
          int result = age;
  
          if (this.name != null) {
              result = this.name.hashCode() * 31 + this.age;
          }
  
          System.out.println("hashCode = " + result);
          return result;
      }
  }
  

  2.1 set接口的使用：

 public static void main(String[] args) {
        Set set =new HashSet<>();
        set.add("华为");
        set.add("oppo");
        set.add("苹果");
        System.out.println("元素个数："+set.size());
        System.out.println(set.toString());

        //删除
        // kedlt.remove(stu1);
        // System.out.println("删除之后的个数"+kedlt.size());
        //kedlt.clear();
        Iterator it= set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        
       
        }

2.2 HashSet：

1. ​ HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。

2. ​ HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。

3. ​ 特点：

​ 不能保证元素的排列顺序**

​ HashSe 不是线程安全的（异步）

​ 集合元素可以是****null**

2.3 TreeSet：

​ TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。

​ TreeSet 支持两种排序方法：自然排序和定制排序。**默认情况下，**TreeSet 采用自然排序。

• TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排列
• 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现Comparable接口。
• 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
• Comparable 的典型实现：
  BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
  Character：按字符的 UNICODE 值来进行比较
  Boolean：true 对应的包装类实例大于 false 对应的包装类实例
  String：按字符串中字符的 UNICODE 值进行比较
  Date、Time：后边的时间、日期比前面的时间、日期大

class Person implements Comparable {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Person o) {

        //小于、等于或大于指定对象，则分别返回负整数、零或正整数。
        //根据age比较排序，小的放前面
        int result = this.age - o.age;

        //如果age返回0开始相同，只会保留一个。所以再次根据name再来比较
        if (result == 0) {
            result = this.name.compareTo(o.name);
        }

        return result;
    }
}

//测试
Set personSet = new TreeSet<>();

Person person1 = new Person("刘亦菲", 20);
Person person2 = new Person("赵丽颖", 22);
Person person3 = new Person("林志玲", 20);

personSet.add(person1);
personSet.add(person2);
personSet.add(person3);

System.out.println("personSet = " + personSet);

在创建集合的时候，就指定的排序规则。

提供一个 Comparator 接口的实现类对象。由该 Comparator 对象负责集合元素的排序逻辑

public class MyComparator implements Comparator {
    @Override
    public int compare(Dog o1, Dog o2) {
        //比较年龄
        int result = o1.getAge() - o2.getAge();
        if (result == 0) {
            //比较姓名
            result = o1.getName().compareTo(o2.getName());
        }
        return result;
    }
}

public static void main(String[] args) {

    //定制排序
    TreeSet dogTreeSet = new TreeSet<>(new MyComparator());

    Dog d3 = new Dog("小黑", 5);
    Dog d4 = new Dog("大黄", 8);
    Dog d5 = new Dog("大白", 3);
    Dog d6 = new Dog("aa", 3);
    Dog d7 = new Dog("ab", 3);


    dogTreeSet.add(d3);
    dogTreeSet.add(d4);
    dogTreeSet.add(d5);
    dogTreeSet.add(d6);
    dogTreeSet.add(d7);

    System.out.println("dogTreeSet = " + dogTreeSet);
}

3Map集合：

• Map用于保存具有映射关系的key-value数据集合

• Map 中的 key 和 value 都可以是任何引用类型的数据

• Map 中的 Key 不允许重复。如果重复添加。后面新增的数据 覆盖原来的value

• Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value(可以重复)

  遍历方式

public static void main(String[] args) {

    Map map = new HashMap<>();

    //添加数据
    map.put("张三", "深圳宝安");
    map.put("李四", "深圳宝安");
    map.put("张三", "深圳南山");
    map.put("3", "深圳南山");
    map.put("a1", "深圳南山");
    map.put("2", "深圳南山");
    map.put("小花", "深圳南山");

    println01(map);

    println02(map);
}

//1.先获取 key   通过 key 获取value
public static void println01(Map map) {

    //1.先获取key   遍历set:增强for 和 迭代器
    Set keySet = map.keySet();

    //2.根据获取value
    for (String key : keySet) {
        String value = map.get(key);
        System.out.println("第一种方式：增强for key = " + key + ", value = " + value);
    }

    Iterator iterator = keySet.iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        String value = map.get(key);
        System.out.println("第一种方式：迭代器 key = " + key + ", value = " + value);
    }


}

//2.获取Entry 自动的包含了 key和 value。不需要二次去获取。推荐
public static void println02(Map map) {

    //1.获取整个entry
    Set> entrySet = map.entrySet();

    //2.直接获取key和value
    //增强for
    for (Map.Entry entry : entrySet) {
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println("第二种方式：for循环 key = " + key + ", value = " + value);
    }

    //迭代器
    Iterator> iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Map.Entry entry = iterator.next();
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println("第二种方式：迭代器 key = " + key + ", value = " + value);
    }

}

3.1 HashMap

• 使用最多的Map集合，HashMap的key是无序的
• 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键
• HashMap是线程不安全
• HashMap：默认大小 = 16 负载因子默认 = 0.75 所以扩容时间：16 x 0.75 = 12 。扩容翻倍
• HashMap中 jdk1.7 和 jdk1.8之后的区别
  • jdk1.7 底层：数组+链接
  • jdk1.8 底层：数组+链表+红黑树

​ 3.2 TreeMap

• 基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序
• 和TreeSet一样，添加的数据必须具有可比性。
  • 自然排序
  • 定制排序

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件
• 由于属性文件里的 key、value 都是字符串类型

1）直接创建对象

Properties properties = new Properties();
properties.setProperty("1001", "小花");
properties.setProperty("1002", "小明");

System.out.println("properties = " + properties);

2）加载配置文件

首选，创建配置文件，通过io流读取配置文件

//Properties 自己创建
Properties properties = new Properties();
properties.setProperty("1001", "小花");
properties.setProperty("1002", "小明");
System.out.println("properties = " + properties);

//从配置文件中读取
Reader reader = new FileReader("src/com/hzit/day12/jdbc.properties");
properties.load(reader);

String username = properties.getProperty("username");
System.out.println("username = " + username);
System.out.println("properties = " + properties);

​