笔记(day17)集合概述、List、Set、比较器

集合Collection

一.概述

​ 集合可以理解为数据结构的封装,根据不同的特性及操作性能进行分类

二.继承体系

三.Collection中常用方法

​ collection是集合中的父类,所以collection中的方法是所有集合中都有的

​ 集合中只能保存引用类型(Object),无法保存基本类型

​ Collection 中并没有查询和修改操作

1. 判断是否为空 isEmpty();

   Collection c = new ArrayList();
   c.isEmpty();
   

2. 添加 add

   c.add("");
   

3. 删除 remove 根据内容删除元素

   c.remove("a");
   

4. 已有元素个数 size()

   c.size();
   

5. 是否包含某个元素 contains()

   c.contains(1);
   

6. 清空集合元素 clean()

   c.clean();
   

7. 转换为数组 toArray()

   Object[] arr = c.toArray();
   

四.迭代器

4.1 概述

​ **迭代器模式∶**它可以使对于序列的底层数据结构的遍历行为与被遍历的对象分离,可以让我们无序关心底层数据结构直接的差异性,提供了统一遍历的标准.(无论底层为何种数据结构都可以使用这个标准进行遍历)

4.2 常用方法

​ 注意 : 迭代器一旦生成,集合不能进行修改,除非重新生成迭代器,也就意味着,在迭代器中删除,只能使用迭代器的remove 不能使用集合的remove

1. hashNext : 判断是否还有元素(boolean)

2. next : 光标向下移动一位,并返回指向的数据

3. remove : 删除当前指向的元素

4.3 forEach

增强for循环foreach是 jdk5.0引入的

语法

会把集合中的每个数据,依次赋值给变量

for(数据类型变量名∶集合){
}

是迭代器iterator的简写方式,如果只是需要做基本的遍历操作,就可以使用使用foreach

但是如果想要做删除操作,还是要使用iterator的,因为foreach无法进行删除操作

public static void main(String[] args){
	Collection c = new ArrayList();
	c.add(1);
	c.add("a");c.add(3);
	for (Object object : c) {
		System.out.println(object);
    }
}

五.List

​ 有序(添加和取出顺序一致)

​ 可重复(可以添加重复数据)

5.2 ArrayList

随机性添加和删除效率较低,查询和修改效率较高

//默认容量为10,每次扩容扩大1.5倍
//创建对象时容量为0,第一次添加数据的时候,长度初始化为10;
ArrayList arr = new ArrayList();
// 尾部添加
arr.add(1);
// 指定位置添加,把数据2添加到第0位上
arr.add(0,2);

//获取 根据下标查询数据
arr.get(0);

//修改 
arr.set(1,12);

//根据内容删除
arr.remove("a");
//传入int,则为根据索引删除
arr.remove(0);
//假如我们要根据内容删除,而这个内容恰好是数字,则需要封装包装类
arr.remove(Integer.valueOf(12));

//遍历
for(int i = 0; i < arr.size(); i++){
	System.out.print(arr.get(i)+" ");
}
for(Object object : arr){
	System.out.print(object);
}

5.3 LinkedList

5.3.1 概述

LinkedList : 底层是一个双向链表,随机性添加和删除效率较高,查询和修改效率较低

5.3.2 使用方法

基本上和ArrayList的使用是一样的

LinkedList arr = new LinkedList();
// 尾部添加
arr.add(1);
arr.add("a");
// 添加到指定位置,把数据2 添加到第0位上
arr.add(0, 2);
// 尾部添加
arr.addLast(4);
arr.offerLast(4);
arr.offer(6);
// 首位添加
arr.push(2);
arr.addFirst(4);
arr.offerFirst(5);
// 核心的添加方法 linkLast 和 linkFirst
		
		
// 获取 根据下标查询数据
System.out.println(arr.get(0));
// 修改 把下标1的值换成12
arr.set(1, 12);

// 根据内容删除
arr.remove("a");
// 传入int,则为根据索引删除
arr.remove(0);
// 假如我们要根据内容删除,而这个内容恰好是数字,则需要封装包装类
arr.remove(Integer.valueOf(12));
System.out.println(arr);

arr.add(1);
arr.add(12);
arr.add(31);
arr.add(3);
arr.add(5);
for (int i = 0; i < arr.size(); i++) {
	System.out.println(arr.get(i));
}
for (Object object : arr) {
	System.out.println(object);
}
	

5.3.3 Get方法实现理念

​ 链表是不支持下标的,只是提供了类似于下标的操作方式,但是本质还是利用循环,一个一个去找,跟数组的下标访问压根不是一回事儿

5.3.4 linkedList类

5.3.5 Node节点类

5.3.6 添加底层实现

5.3.7 删除

六.set

6.1 特性

无序 : 不保证有序, 可能有序, 可能无序

不可重复 : 不能添加重复数据
不能做修改和查询操作

6.2 TreeSet

6.2.1 特征

底层是红黑树,添加的元素会按照特定的顺序进行排序

数字 : 从小到大

日期 : 自然日期

字符串 : 按照每位的ASCII码值进行排序

既然会排序,说明一定会进行比较不同类型是没有可比性的,因此treeSet必须保存同一类型

6.2.2 使用

​ 没有查询和修改功能

TreeSet ts = new TreeSet);
//添加
ts.add(1);
ts.add(12);
ts.add(3);
ts.add(9);
//java.lang.ClassCastException: java.lang.Integer cannot be cast toll java.lang.String
// ts.add("aa");
//根据内容删除
ts.remove(2);
//没有查询和修改功能
ts.size();
ts.isEmpty();
ts.contains(2);
ts.clear();
System.out.println(ts);

6.2.3 注意

TreeSet set = new TreeSet();
set.add("1");
set.add("7");
//没有重复数据
set.add("1");
//先比较第一位,按位比较
set.add("14");
set.add("16");
set.add("6");
System.out.print(set);//1 14 16 6 7;

6.3 HashSet

6.3.1 概述

​ 底层是Haspmap,set其实就是map的key部分,因此不能做查询和修改操作

七.排序

7.1 comparable

​ 为什么会自动排序呢?因为添加的这些对象的类,都实现了Comparable接口,并实现了compareTo方法

​ 要排序的类会根据compareTo方法的返回值,进行排序

​ 返回0说明相等,就不添加

​ 返回小于0的值,就说明要添加的元素比集合中的小,就会被放到前面

​ 返回大于0的值,就说明要添加的元素比集合中的大,就会被放到后面

​ 因此我们自定义的类想要被排序,就要实现comparable接口并覆写compareTo方法

public class Test_01 {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new User(18, "张三"));
		ts.add(new User(16, "张三"));
		ts.add(new User(19, "张三"));
		ts.add(new User(15, "张三"));
		for (Object object : ts) {
			System.out.println(object);
		}	
	}
}
class User implements Comparable{
	@Override
	public int compareTo(Object o) {
		if(o instanceof User){
			User user = (User) o;
			return user.age - this.age;
		}
		return 0;
	}

	private int age;
	private String name;
	
	public User(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	
	public User() {
		super();
	}
	
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}
}

7.2 comparator

​ 数字会默认从小到大排序,那么如果我们的需求是,要求数字从大到小排序呢?

​ 数字升序是因为Integer类中有compareTo方法,并定义了升序排序,而我们并没有办法去修改Integer类中的源码,但是我们可以扩展Comparator:比较器类,当comparable和comparator同时存在的时候.comparator优先级大于comparable

​ 应用场景︰

​ 如果保存的元素的类,是我们写的,肯定要实现comparable接口

​ 如果保存的元素的类,不是我们写的,并且排序规则也无法满足我们的需求,需要使用comparator来进行扩展

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
class User implements Comparator<User> {
    private String name;
    private int age;
    private boolean sex;
 
    public User() {
    }
 
    public User(String name, int age, boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public boolean isSex() {
        return sex;
    }
 
    public void setSex(boolean sex) {
        this.sex = sex;
    }
 
    @Override
    public int compare(User o1, User o2) {
        return o1.age-o2.age;
    }
}
public class Test{
    public static void main(String[] args) {
        User user1=new User("dingli",25,true);
        User user2=new User("huxiaojuan",24,false);
        User user3=new User("xxx",24,false);
        List<User> list=new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        Collections.sort(list, new User()); //类实现了的Comparator能满足需求
        System.out.println("类自身实现Comparator:"+list);
        //现在我想要按照名字升序，显然类中实现的不能满足要求，于是可以在类外自己实现想要的比较器
        Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getName().compareTo(o2.getName()); //按照名字升序
            }
        });
        System.out.println("匿名内部类方式："+list);
        //由于Comparator接口是一个函数式接口，因此根据jdk1.8新特性，我们可以采用Lambda表达式简化代码
        Collections.sort(list,(u1,u2)->{return u1.getName().compareTo(u2.getName());});
        System.out.println("Lambda表达式方式："+list);
    }
}

7.3 Collections

​ Collections.sort() 方法是用于对 List 集合中的元素进行排序的。这个方法有两个重载版本：一个接受一个 List 参数（要求列表中的元素实现了 Comparable 接口），另一个接受一个 List 参数和一个 Comparator 参数（允许你指定一个自定义的比较器）。

public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add(1);
		al.add(16);
		al.add(5);
		al.add(2);
		al.add(7);
		
		Collections.sort(al);
		System.out.println(al);//[1, 2, 5, 7, 16]
		Collections.sort(al,new Comparator() {
		
			@Override
			public int compare(Object o1, Object o2) {
				return (Integer)o2 - (Integer)o1 ;
			}
		});
		System.out.println(al);//[16, 7, 5, 2, 1]
	}

7.4 总结

• Comparable 是"比较"的意思，而 Comparator 是"比较器"的意思；
• Comparable 是通过重写 compareTo 方法实现排序的，而 Comparator 是通过重写 compare 方法实现排序的
• 一个类只有实现了Comparable接口才支持排序,当一个类已经实现Comparable接口但是他的排序方式不满足我的需求时,才使用Comparator接口来满足需求
• 自己写的类优先实现Comparable接口
• 当一个类没有comparab接口是时没办法直接进行排序的,必须去再次实现Comparator接口才可以排序(就算类实现了Comparator接口也无法直接使用Collections.sort() 方法排序)
• 当Comparable和Comparator同时存在时,Comparator优先级高

使用规则:

• 如果排序逻辑是要排序的对象固有的并且不会更改，使用 Comparable。
• 如果需要定义多个排序规则或对未实现 Comparable 的对象进行排序时，使用 Comparator。
• 如果一个类实现了 Comparable 接口支持自然排序，仍然可以使用 Comparator 进行自定义排序。

八.散列表

8.1 概述

​ 存放单链表的数组(数组里存放的是节点)

​ (Hash table，也叫哈希表)，是根据键(Key)而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。

8.2 底层实现

​ java中,把散列表封装在HashTable HashMap 和 HashSet中,HashTable已经过时,不推荐使用,被HashMap代替

​ 需要注意 : 使用散列表,需要 同时覆写equals方法和hashCode方法,才能确保数据的唯一性节点中包含4个属性 : key , value , hash , next

添加过程 :

1. 调用key的hashCode方法,生成hash值
2. 进行hash算法得到对应的值
3. 生成数组下标,判断该位置是否有数据
4. 如果没有数据,则创建节点对象,把key和value保存在节点中,并把节点对象 保存在数组中
5. 如果有数据,则调用key的equals方法和对应链表中每一个数据进行比较
6. 如果相同,则不添加,但是value值覆盖原来的value
7. 如果都不相同,说明他们只是下标一样,内容并不一样,所以把该节点对象插入在链表的尾部
8. 1.8开始新特性,为了提高查询效率,引入红黑树,因为链表查询效率较低,所以会在添加的时候进行判断如果链表个数大于等于7,把该链表转换为红黑树存储

​ HashMap默认初始化容量为16,并且默认加载因子是0.75 (16*0.75=12 , 也就是说到达12个就开始扩容)

九.map

9.1 HashMap

key不可以重复, value 可以重复

public static void main(String[] args) {
Map map = new HashMap();
// 添加
map.put("A", 11);
map.put("A", 12);
map.put("B", 11);
map.put("B", 13);
System.out.println(map);// {A=12, B=13}
// 查询 根据key值查询 value的值
System.out.println(map.get("A"));// 12
System.out.println(map.get("B"));// 13

// 改 , 和添加一样,已有key为修改,没有的key 为添加
map.put("B", 17);

// 删除 根据key删除整个映射关系
map.remove("A");
System.out.println(map);// {B=17}

// 个数
System.out.println(map.size());// 1

// 判断是否包含某个key
System.out.println(map.containsKey("A"));// false

// 判断是否包含某个value
System.out.println(map.containsValue(17));// true

// 清空
map.clear();
System.out.println(map);// {}

map.put("A", 13);
map.put("B", 23);
		
// keySet 获取所有的类封装到set中返回
Set set = map.keySet();
for (Object object : set) {
	System.out.print(object + " : " + map.get(object)+" ");//A : 13 B : 23 
}System.out.println();
		
// values 获取所有value并封装到集合中返回
Collection values = map.values();
for (Object object : values) {
	System.out.print(object+" ");//13 23 
}System.out.println();
		
// entrySet 把key和value封装到entry对象中,并保存在set中返回
Set entrys = map.entrySet();
for (Object object : entrys) {
	Entry entry = (Entry) object;
	System.out.print(entry.getKey()+" : "+entry.getValue()+" ");//A : 13 B : 23 
	}
}

9.2 TreeMap

​ 使用treeMap ,key元素类,必须实现Comparable接口并覆写compareTo方法注意treeMap中,排序是按照key进行的和value没有关系

public static void main(String[] args) {
	TreeMap map = new TreeMap();
	map.put("a",12);
	map.put("b",11);
    map.put("x",10);
    map.put("a1",22);
	System.outprintln(map);
}

十.泛型

10.1 概述

​ 在编译时,进行类型检查

​ 默认集合中是可以保存任意类型元素的(Object),使用泛型后可以使类型统一

​ 因为我们在使用集合的时候,虽然可以保存任意类型元素,但是往往我们只会保存同一种类型由于内部是Object类型,导致所有类型存储的时候都会发生多态,而多态丢失子类特有的属性

​ 因此我们使用的时候,需要向下转型(强制类型转换)如果使用泛型,则不再需要类型转换,使用更方便

​ 泛型只能写引用类型

10.2 使用

public static void main(String[] args) {
	List<Integer> list = new ArrayList<Integer>();
	list.add(2);
	list.add(5);
	list.add(1);
	//报错,只可以添加int类型的数据
	//list.add("2");
}

TreeMap map = new TreeMap();
map.put("a",12);
map.put("b",11);
map.put("x",10);
map.put("a1",22);
System.outprintln(map);

}

# 十.泛型

## 10.1 概述

​	在编译时,进行类型检查
​	默认集合中是可以保存任意类型元素的(Object),使用泛型后可以使类型统一
​	因为我们在使用集合的时候,虽然可以保存任意类型元素,但是往往我们只会保存同一种类型由于内部是Object类型,导致所有类型存储的时候都会发生多态,而多态丢失子类特有的属性
​	因此我们使用的时候,需要向下转型(强制类型转换)如果使用泛型,则不再需要类型转换,使用更方便
​	**泛型只能写引用类型**

## 10.2 使用

```java
public static void main(String[] args) {
	List<Integer> list = new ArrayList<Integer>();
	list.add(2);
	list.add(5);
	list.add(1);
	//报错,只可以添加int类型的数据
	//list.add("2");
}