java list set map日子记录

List集合

概念

是一个容器,作用为存放多个数据,通常用来替代数组

特点

1. 只能存放引用类型

2. 所有集合都来自于java.util包

List , Set , Map都是接口

List的存储特点

有序,有下标,元素可以重复

List的常用实现类

1. ArrayList (常用)

   • JDK1.2 底层数组实现 查询快,增删慢 线程不安全,效率高

2. LinkedList

   • JDK1.2 底层链表实现 查询慢,增删快 线程不安全,效率高

3. Vector

   • JDK1.0 底层数组实现 都慢 线程安全,效率低

创建

• 建议使用多态

List 集合名=new 实现类();

常用方法

• 集合名.方法名(实参列表)

1. boolean add(元素): 往集合末尾添加一个元素

2. void add(下标, 元素): 将元素添加至指定下标位置

3. boolean addAll(集合名)：将指定集合元素添加至当前集合末尾

4. boolean addAll(下标，集合名)：将指定集合元素添加至当前集合指定下标位置

5. int size()：获取集合长度

6. 元素 get(下标)：获取指定下标位置的元素

   • 下标不可超出使用范围，否则报出下标越界异常

7. boolean contains(元素)：判断是否包含指定元素

8. boolean containsAll(集合名)：判断当前集合中是否包含指定集合的所有元素

9. 下标 indexOf(元素)：获取指定元素第一次出现的下标

10. 下标 lastIndexOf(元素)：获取指定元素最后一次出现的下标

11. boolean isEmpty()：判断集合元素是否为空，不可判比null值

12. 被删除的元素 remove(下标):删除指定下标位置的元素

13. boolean remove(元素)：删除指定元素

    • 如果集合元素为整数值，则会优先认定值为下标。所以删除整数值元素时只能通过下标删除

14. 旧元素 set(下标，新元素)：将指定下标位置的值替换为新元素值

15. Object[] toArray()：将集合转换为数组

遍历

1. 下标遍历

for(int i=0;i<集合名.size();i++){
    //通过集合名.get(i)的方式获取当前元素
}

List list = new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);

        //下标遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();

迭代器遍历

1. 获取集合的迭代器：集合名.iterator()

2. 操作迭代器：

   • boolean hasNext()：判断是否存在下一元素

   • 元素 next()：使指针后移一位，获取下一元素

3. 使用：

   • 迭代过程中不可增删元素

   • 一次迭代只能调用一次next方法，否则迭代与操作元素数量不一致

//获取迭代器
        Iterator it = list.iterator();
        //利用循环操作迭代器
        while(it.hasNext()){
            Object o = it.next();
            if (o != null) {
                System.out.print(o+"  ");
            }
        }
        System.out.println();

外遍历forEach
for(数据类型 元素名:集合名){
    //元素名就代表正在被遍历的元素
}

for (Object o : list) {
            System.out.print(o+"  ");
        }
        System.out.println();

1. - 遍历过程中无法增删元素
   - JDK5.0

2. 自遍历forEach

   - JDK8.0
   - 集合名.forEach(Consumer接口实现类对象)


list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                //参数o就表示当前元素
                System.out.print(o+"  ");
            }
        });
        System.out.println();
        //自遍历forEach-lambda
        list.forEach(o -> System.out.print(o + "  "));

## 泛型

- 用于集合： 约束集合可存放的数据类型

## 泛型

- 用于集合： 约束集合可存放的数据类型

~~~java
List<泛型类型> 集合名=new 实现类名<泛型类型>();
~~~

### 使用

1. 存放类型为基本类型时，需要将泛型类型声明为对应包装类型

2. 前后泛型声明必须一致

3. 前边泛型不可省略

4. 后边泛型<>内容可省

   ~~~java
   List<泛型类型> 集合名=new 实现类名<>();
   ~~~

~~~java
package com.by.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;

public class Test4 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
       /* list.add(5.5);
        list.add("abc");*/
        //四种遍历方式
        //下标遍历
        for (int i = 0; i < list.size(); i++) {
            //接收当前元素
            Integer n = list.get(i);
            System.out.print(n+"  ");
        }
        System.out.println();
        //迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Integer n = it.next();
            System.out.print(n+"  ");
        }
        System.out.println();
        //外遍历
        for (Integer i : list) {
            System.out.print(i+"  ");
        }
        System.out.println();
        //自遍历
        list.forEach(new Consumer() {
            @Override
            public void accept(Integer i) {
                System.out.print(i+"  ");
            }
        });
        System.out.println();
        //lambda
        list.forEach(i-> System.out.print(i+"  "));
        
    }
}
~~~

Set集合

Collection

• 是List和Set的父接口

• 所有集合都是由Collection或者Map派生

特点

1. 内部存放List和Set的共性方法

2. 没有直接实现类

Set的存储特点

无序,无下标,元素不可重复

Set的常用实现类

1. HashSet

   • JDK1.2 底层哈希表(数组+链表)实现 线程不安全,效率高

2. LinkedHashSet

   • JDK1.2 使HashSet的子类,底层哈希表实现 线程不安全,效率高

3. TreeSet

   • JDK1.2 底层红黑树实现,是SortedSet的实现类 线程不安全,效率高

   红黑树:树状结构存放数据,使用的是二分查找法,特点为查询效率快

创建

• 建议使用多态

Set<泛型> 集合名=new 实现类名<>();

常用方法

• 所有方法都继承自Collection,无独有方法

遍历

1. 迭代器遍历

2. 外遍历forEach

3. 自遍历forEach

哈希表的去重原理

1. 先调用元素的hashCode方法获取哈希码值

2. 通过哈希码值%数组长度(16)得到存放下标

3. 如果下标位置未存有元素,则直接存放

4. 如果下标位置存有元素, 则调用当前元素的equals方法与下标位置元素进行值的比较

5. 都不相同, 在下标位置上继续链表存放

6. 有相同,则舍弃添加当前元素

使用

1. HashSet和LinkedHashSet如果存放的是自定义类型，则必须重写hashCode和equals方法才能实现去重

2. LinkedHashSet可以保证元素存入与取出的顺序一致

3. TreeSet可以实现对元素进行默认的升序排序

   • 如果TreeSet中存放的是自定义类型，则必须自定义排序规则

   • 排序方式:

     1. 实现Comparable接口，重写CompareTo方法

        • 思路：让当前对象this和参数对象o进行比较

        • 实现：对谁排序，就让谁实现

        • 规则：

          • 从小到大：

            this的值>o的值，返回正数

            this的值

          • 从大到小：

            this的值>o的值，返回负数

            this的值

            相等返回0

package com.by.entity;

public class Student implements Comparable{
    private String name;
    private int age;
    private double score;

    //省略getter、setter、构造

    @Override
    public int compareTo(Student o) {
        //根据学生成绩从高到底排序
        if (this.score > o.score) {
            return -1;
        } else if (this.score < o.score) {
            return 1;
        }
        return 0;
    }
}


实现Comparator接口，重写compare方法

- 思路: 让参数o1和o2进行比较
- 实现:在集合创建处的小括号内传入实现类对象

Set set = new TreeSet<>((o1,o2)->{
            //根据学生成绩从低到高
            if (o1.getScore() > o2.getScore()) {
                return 1;
            } else if (o1.getScore() < o2.getScore()) {
                return -1;
            }
            return 0;
        });


1. - > 1. 默认识别Comparable,但是Comparator优先级更高
     > 2. Comparator更能保护类的单一职责,有利于后期代码的维护, 集合排序扩展性更高,更推荐该方式

2. TreeSet去重规则:当compareTo或compare方 法返回值为0时去重

Map集合

存储特点

• 以键值对的形式存储数据

• 键(key): 无序,无下标,元素不可重复

• 值(value): 无序,无下标,元素可以重复

常用实现类

1. HashMap

   • JDK1.2 底层哈希表实现 线程不安全,效率高

2. LinkedHashMap

   • JDK1.2 是HashMap的子类,底层哈希表实现 线程不安全,效率高

3. TreeMap

   • JDK1.2 是SortedMap的实现类,底层红黑树实现 线程不安全,效率高

4. Hashtable

   • JDK1.0 底层哈希表实现 线程安全,效率低

5. Properties

   • JDK1.0 是Hashtable的子类,底层哈希表实现 线程安全,效率低

创建

• 建议使用多态

Map<键的泛型,值的泛型> 集合名=new 实现类名<>();

常用方法

K: 键

V: 值

1. V put(K,V):向集合中添加一个键值对

   • 如果键已经存在,则进行值的覆盖

2. int size(): 获取集合长度

3. boolean containsKey(K): 判断集合是否包含指定键

4. boolean containsValue(V): 判断集合是否包含指定值

5. V get(K): 根据键获取值

## 遍历

1. 键遍历
   - Set keySet(): 获取集合所有的键放入Set集合返回

~~~java
//先获取所有的键
        Set set1 = map.keySet();
        //遍历键
        set1.forEach(k -> System.out.println(k + "  " + map.get(k)));
~~~

2. 值遍历
   - Collection values(): 获取集合所有的值放入Collection集合返回

~~~java
//获取所有的值
        Collection coll = map.values();
        //遍历值
        for (String s : coll) {
            System.out.println(s);
        }
~~~

3. 键值对遍历
   - Set<  Map.Entry >  entrySet(): 将所有的键值对对象放入Set集合返回
   - entry对象.getKey(): 获取entry对象中的键
   - entry对象.getValue():获取entry对象中的值

~~~java
//获取到所有的entry对象
        Set> set2 = map.entrySet();
        //遍历entry对象
        set2.forEach(entry-> System.out.println(entry.getKey()+","+entry.getValue()));
~~~

4. 自遍历forEach
   - 集合名.forEach(BiConsumer接口实现类对象)

~~~java
System.out.println("自遍历-->匿名内部类:");
		map.forEach(new BiConsumer() {
            @Override
            public void accept(String k, String v) {
                System.out.println(k+"  ,  "+v);
            }
        });
        System.out.println("自遍历-->lambda:");
        map.forEach((k,v)->System.out.println(k+"  ,  "+v));
~~~

使用

1. 除去TreeMap之外, 如果键为自定义类型,则必须重写hashCode和equals方法才能实现去重

2. HashMap可以存放null值,键只能有一个null,值可以存在多个null

3. LinkedHashMap在HashMap的基础上可以保证元素存入和取出的顺序一致

4. TreeMap可以根据键进行默认的升序排序

   • 如果键为自定义类型,则需要自定义排序规则,方式与TreeSet一致

   • 键不可为null,否则排序会导致空指针

   • 仍然在compareTo或者compare方法返回值为0时去重

5. Hashtable无法存放null值

6. Properties只能存放String类型的数据

   • 不推荐使用多态

   • 无法使用泛型

   • setProperty(String,String): 向集合中添加一个键值对

   • String getProperty(String): 根据键获取值

   • load(输入流): 通过输入流将配置文件的内容读取到集合中