Java 集合

集合：提供一种存储空间可变的存储模型，存储的数据容量可以随时改变。

• 整个集合框架就围绕一组标准接口而设计。直接使用这些接口的标准实现
• 实现类：ArrayList、LinkedList、HashSet、HashMap
• 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中， 所以当使用集合框架的时候需要进行导包
  
  
  

Collection集合概述

• 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
• JDK不提供此接口的任何直接对象，它提供更具体的子接口实现

Collection集合基本使用

public class collectionDemo01{
	public static void main(String[] args){
		collection<String> c=new ArrayList<String>();
		c.add("hello");
		c.add("world");
		c.add("java");
		
		System.out.println(c);
		
	}
}

Collection集合的常用方法

boolean add(E e) 添加元素
boolean remove(Object o) 从集合中移除指定的元素
void clear() 清空集合中的元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中元素的个数

Collection集合的遍历

迭代器的介绍

• 迭代器，集合的专用遍历方式
• Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
• 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

public class IteratorDemo {
	public static void main(String[] args) {
		//创建集合对象
		Collection<String> c = new ArrayList<>();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		c.add("javaee");
		//Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
		Iterator<String> it = c.iterator();
		//用while循环改进元素的判断和获取
		while (it.hasNext()) {
		String s = it.next();
		System.out.println(s);
		}
	}
}

List集合

List集合：有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素

List集合特点：有索引、可以存储重复元素、元素存取有序

List集合的特有方法

void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

数据结构

栈：先进先出
队列：先进先出
数组结构：查询快、增删慢
队列结构：查询慢、增删快

List集合的实现类

ArrayList集合：底层是数组结构实现，查询快、增删慢
LinkedList集合：底层是链表结构实现，查询慢、增删快

LinkedList集合方法

public void addFirst(E e) 在该列表开头插入指定的元素
public void addLast(E e) 将指定的元素追加到此列表的末尾
public E getFirst() 返回此列表中的第一个元素
public E getLast() 返回此列表中的最后一个元素
public E removeFirst() 从此列表中删除并返回第一个元素
public E removeLast() 从此列表中删除并返回最后一个元素

import java.util.*;
 
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     //第一种遍历方法使用 For-Each 遍历 List
     for (String str : list) {            //也可以改写 for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
     }
 
     //第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历 使用迭代器进行相关遍历
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}

Set集合

set集合：

• 元素存取无序
• 没有索引、只能通过迭代器或增强for循环遍历
• 不能存储重复元素

Set集合的基本使用

public class SetDemo{
	public static void main(String[] args){
		Set<String> set = new HashSet<String>();
		//添加元素
		set.add("hello");
		set.add("world");
		set.add("java");
		//包含不重复的集合
		set.add("world");
		for (String s: set){
			System.out.println(s);
		}
	}
}

哈希值
哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。

Object类中的public int hashCode()：返回对象的哈希码值

哈希值的特点

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的
• 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

HashSet集合概述和特点
HashSet集合的特点

• 底层数据结构是哈希表
• 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
• 没有带索引的方法，所以不能使用普通for循环遍历
• 由于是Set集合，所以是不包含重复元素的集合

TreeSet集合概述和特点
TreeSet集合概述

元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法

• TreeSet()：根据其元素的自然排序进行排序
• TreeSet(Comparator comparator) ：根据指定的比较器进行排序

没有带索引的方法，所以不能使用普通for循环遍历

由于是Set集合，所以不包含重复元素的集合

LinkedHashSet集合概述和特点
LinkedHashSet集合特点

• 哈希表和链表实现的Set接口，具有可预测的迭代次序
• 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
• 由哈希表保证元素唯一，也就是说没有重复的元素

泛型

是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型。它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

格式

<类型>：指定一种类型的格式。这里的类型可以看成是形参
<类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

好处

把运行时期的问题提前到了编译期间
避免了强制类型转换

泛型类
定义格式

修饰符 class 类名<类型> { }

public class Generic<T> {
	private T t;
	public T getT() {
		return t;
	}
	public void setT(T t) {
		this.t = t;
	}
}

public class GenericDemo {
	public static void main(String[] args) {
		Generic<String> g1 = new Generic<String>();
		g1.setT("林青霞");
		System.out.println(g1.getT());
		Generic<Integer> g2 = new Generic<Integer>();
		g2.setT(30);
		System.out.println(g2.getT());
		Generic<Boolean> g3 = new Generic<Boolean>();
		g3.setT(true);
		System.out.println(g3.getT());
	}
}

泛型方法

定义格式

修饰符 <类型> 返回值类型 方法名(类型 变量名) { }

//带有泛型方法的类
public class Generic {
	public <T> void show(T t) {
		System.out.println(t);
	}
}

public class GenericDemo {
	public static void main(String[] args) {
		Generic g = new Generic();
		g.show("林青霞");
		g.show(30);
		g.show(true);
		g.show(12.34);
	}
}

泛型接口
格式

修饰符 interface 接口名<类型> { }

public interface Generic<T> {
	void show(T t);
}

public class GenericImpl<T> implements Generic<T> {
	@Override
	public void show(T t) {
		System.out.println(t);
	}
}

public class GenericDemo {
	public static void main(String[] args) {
		Generic<String> g1 = new GenericImpl<String>();
		g1.show("林青霞");
		Generic<Integer> g2 = new GenericImpl<Integer>();
		g2.show(30);
	}
}

类型通配符

• 为了表示各种泛型List的父类，可以使用类型通过配符

类型通配符：<?>

• List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其

类型通配符上限：<? extends 类型>

• List<? extends Number>：它表示的类型是Number或者其子类型

类型通配符下限：<? super 类型>

• List<? super Number>：它表示的类型是Number或者其父类型

public class GenericDemo {
	public static void main(String[] args) {
		//类型通配符：<?>
		List<?> list1 = new ArrayList<Object>();
		List<?> list2 = new ArrayList<Number>();
		List<?> list3 = new ArrayList<Integer>();
		System.out.println("--------");
		//类型通配符上限：<? extends 类型>
		// List<? extends Number> list4 = new ArrayList<Object>();
		List<? extends Number> list5 = new ArrayList<Number>();
		List<? extends Number> list6 = new ArrayList<Integer>();
		System.out.println("--------");
		//类型通配符下限：<? super 类型>
		List<? super Number> list7 = new ArrayList<Object>();
		List<? super Number> list8 = new ArrayList<Number>();
		// List<? super Number> list9 = new ArrayList<Integer>();
	}
}

可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

修饰符 返回值类型 方法名(数据类型… 变量名) { }

public class ArgsDemo01 {
	public static void main(String[] args) {
		System.out.println(sum(10, 20));
		System.out.println(sum(10, 20, 30));
		System.out.println(sum(10, 20, 30, 40));
		System.out.println(sum(10,20,30,40,50));
		System.out.println(sum(10,20,30,40,50,60));
		System.out.println(sum(10,20,30,40,50,60,70));
		System.out.println(sum(10,20,30,40,50,60,70,80,90,100));
		}
		// public static int sum(int b,int... a) {
		// return 0;
		// }
	public static int sum(int... a) {
		int sum = 0;
			for(int i : a) {
				sum += i;
		}
		return sum;
	}
}

Arrays工具类中有一个静态方法：

• public static List asList(T… a)：返回由指定数组支持的固定大小的列表
• 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法：

• public static List of(E… elements)：返回包含任意数量元素的不可变列表
• 返回的集合不能做增删改操作

Set接口中有一个静态方法：

• public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合
• 在给元素的时候，不能给重复的元素
• 返回的集合不能做增删操作，没有修改的方法

public class ArgsDemo02 {
	public static void main(String[] args) {
		//public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
		// List<String> list = Arrays.asList("hello", "world", "java");
		//
		 list.add("javaee"); //UnsupportedOperationException
		 list.remove("world"); //UnsupportedOperationException
		// list.set(1,"javaee");
		//
		// System.out.println(list);
		//public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可变列
		表
		// List<String> list = List.of("hello", "world", "java", "world");
		//
		 list.add("javaee");//UnsupportedOperationException
		 list.remove("java");//UnsupportedOperationException
		 list.set(1,"javaee");//UnsupportedOperationException
		//
		// System.out.println(list);
		//public static <E> Set<E> of(E... elements) ：返回一个包含任意数量元素的不可变集合
		// Set<String> set = Set.of("hello", "world", "java","world");
		//IllegalArgumentException
		//Set<String> set = Set.of("hello", "world", "java");
		// set.add("javaee");//UnsupportedOperationException
		// set.remove("world");//UnsupportedOperationException
		//System.out.println(set);
	}
}

Map

Map集合遍历

import java.util.*;
public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

Map集合格式

interface Map<K,V> K：键的类型；V：值的类型

特点：

• 键值对映射关系
• 一个键对应一个值
• 键不能重复，值可以重复
• 元素存取无序

Map集合的基本使用

public class MapDemo01 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		//V put(K key, V value) 将指定的值与该映射中的指定键相关联
		map.put("itheima001","林青霞");
		map.put("itheima002","张曼玉");
		map.put("itheima003","王祖贤");
		map.put("itheima003","柳岩");
		//输出集合对象
		System.out.println(map);
	}
}

基本功能
方法

V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数

public class MapDemo02 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		//V put(K key,V value)：添加元素
		map.put("张无忌","赵敏");
		map.put("郭靖","黄蓉");
		map.put("杨过","小龙女");
		//V remove(Object key)：根据键删除键值对元素
		// System.out.println(map.remove("郭靖"));
		// System.out.println(map.remove("郭襄"));
		//void clear()：移除所有的键值对元素
		// map.clear();
		//boolean containsKey(Object key)：判断集合是否包含指定的键
		// System.out.println(map.containsKey("郭靖"));
		// System.out.println(map.containsKey("郭襄"));
		//boolean isEmpty()：判断集合是否为空
		// System.out.println(map.isEmpty());
		//int size()：集合的长度，也就是集合中键值对的个数
		System.out.println(map.size());
		//输出集合对象
		System.out.println(map);
	}
}

Map集合的获取功能

V get(Object key) 根据键获取值
Set keySet() 获取所有键的集合
Collection values() 获取所有值的集合
Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合

public class MapDemo03 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素
		map.put("张无忌", "赵敏");
		map.put("郭靖", "黄蓉");
		map.put("杨过", "小龙女");
		//V get(Object key):根据键获取值
		// System.out.println(map.get("张无忌"));
		// System.out.println(map.get("张三丰"));
		//Set<K> keySet():获取所有键的集合
		// Set<String> keySet = map.keySet();
		// for(String key : keySet) {
		// System.out.println(key);
		// }
		//Collection<V> values():获取所有值的集合
		Collection<String> values = map.values();
		for(String value : values) {
		System.out.println(value);
		}
	}
}

集合的遍历
获取所有键的集合。用keySet()方法实现

遍历键的集合，获取到每一个键。用增强for实现

根据键去找值。用get(Object key)方法实现

遍历一

public class MapDemo01 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素
		map.put("张无忌", "赵敏");
		map.put("郭靖", "黄蓉");
		map.put("杨过", "小龙女");
		//获取所有键的集合。用keySet()方法实现
		Set<String> keySet = map.keySet();
		//遍历键的集合，获取到每一个键。用增强for实现
		for (String key : keySet) {
		//根据键去找值。用get(Object key)方法实现
		String value = map.get(key);
		System.out.println(key + "," + value);
		}
	}
}

遍历二

public class MapDemo02 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素
		map.put("张无忌", "赵敏");
		map.put("郭靖", "黄蓉");
		map.put("杨过", "小龙女");
		//获取所有键值对对象的集合
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
			//遍历键值对对象的集合，得到每一个键值对对象
			for (Map.Entry<String, String> me : entrySet) {
			//根据键值对对象获取键和值
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key + "," + value);
		}
	}
}

Collections集合工具类

集合操作的工具类

public static void sort(List list) 将指定的列表按升序排序
public static void reverse(List<?> list) 反转指定列表中元素的顺序
public static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表

public class CollectionsDemo01 {
	public static void main(String[] args) {
		//创建集合对象
		List<Integer> list = new ArrayList<Integer>();
		//添加元素
		list.add(30);
		list.add(20);
		list.add(50);
		list.add(10);
		list.add(40);
		//public static <T extends Comparable<? super T>> void sort•(List<T>list)：将指定的列表按升序排序
		
		// Collections.sort(list);
		//public static void reverse•(List<?> list)：反转指定列表中元素的顺序
		// Collections.reverse(list);
		//public static void shuffle•(List<?> list)：使用默认的随机源随机排列指定的列表
		Collections.shuffle(list);
		System.out.println(list);
	}
}