Day 13 Java集合

Day 13 Java集合

一、概念

集合和数组一样，也是一个容器，但集合的长度不定，可以向集合中任意添加元素，且集合中元素的类型也不固定

二、 集合的框架结构

三、Collection接口详解

3.1Collection接口中常用方法

方法名	描述
add(E e)	确保此 collection 包含指定的元素（可选操作）。
addAll(Collection<? extends E> c)	将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
clear()	移除此 collection 中的所有元素（可选操作）。
contains(Object o)	如果此 collection 包含指定的元素，则返回true。
containsAll(Collection<?> c)	如果此 collection 包含指定 collection 中的所有元素，则返回 true。
equals(Object o)	比较此 collection 与指定对象是否相等。
isEmpty()	如果此 collection 不包含元素，则返回true。
iterator()	返回在此 collection 的元素上进行迭代的迭代器。
remove(Object o)	从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
removeAll(Collection<?> c)	移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
retainAll(Collection<?> c)	仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
size()	返回此 collection 中的元素数。
toArray()	返回包含此 collection 中所有元素的数组。

3.2Collection的子接口 List

特点：有序、有下标、元素可以重复

方法名	描述
add(int index, E element)	在列表的指定位置插入指定元素（可选操作）。
get(int index)	返回列表中指定位置的元素。
indexOf(Object o)	返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
lastIndexOf(Object o)	返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
listIterator()	返回此列表元素的列表迭代器（按适当顺序）。
remove(int index)	移除列表中指定位置的元素（可选操作）。
set(int index, E element)	用指定元素替换列表中指定位置的元素（可选操作）。
subList(int fromIndex, int toIndex)	返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

3.2.1 List接口的实现类 ArrayList【重点 】

特点：有序、有下标、元素可以重复

以数组结构存储

public class ArrayListDemo {
         	public static void main(String[] args) {
              	//创建一个ArrayList集合
            	ArrayList<String> list = new ArrayList<>();//构造方法中的泛型可以省略
              	list.add("zhangsan");//向集合中添加元素
              	list.add("lisi");
              	list.add("wangwu");
              	System.out.println(list.isEmpty());//判断list集合是否为空集合
              	System.out.println(list.size());//查看集合中元素的个数
              	System.out.println(list.get(1));//获取集合中下标为1的元素
              	System.out.println(list.set(1,"zhaoliu"));//修改集合中下标为1的元素
              	System.out.println(list.contains("wangwu"));//查看"wangwu"是否是集合中的元素
              	list.remove("wangwu");//删除集合中"wangwu"元素
              	list.remove(1);//删除集合中下标为1的元素
              	//for循环遍历集合
                for(int i=0; i<list.size(); i++){
                  System.out.println(list.get(i));
                }
              	//使用Iterator迭代器遍历
              	Iterator<String> it = list.iterator();//获取迭代器
                while(it.hasNext()){
                  System.out.println(it.next());
                }
              	//使用ListIterator迭代器遍历
              	ListIterator<String> lit = list.listIterator();
                while(lit.hasNext()){
                  System.out.println(lit.next());
                }
              	//反向遍历
                while(lit.hasPrevious()){
                  System.out.println(lit.previous());
                }
         }
}

3.3 什么是泛型

泛型就是可以表示一个广泛数据类型的类型参数（泛型只能表示引用类型）,把数据类型作为参数来传递。
形式参数：声明方法时，在方法的参数列表中声明，而且在方法体中会使用到，但是是一个未知的数据
类型参数：在一个类中声明一个未知的数据类型，在类中可以使用这个类型，但是具体类型取决于实例化时传入的实际类型

3.3.2 泛型的声明

1）泛型可以声明在方法中：(泛型方法)
public static <标识符> void fun(){}

2）泛型可以声明在类中：（泛型类）
public class 类名<标识符>{
	//类体
	//泛型可以在类中充当成员变量
	//泛型可以再类中充当方法的返回值
	//泛型可以在类中充当方法的参数
}

3）泛型可以声明在接口中：（泛型接口）
public interface 接口名<标识符>{
	//成员
	//泛型可以充当接口中方法的返回值
	//泛型可以充当接口中方法的参数
}

3.3.3说明

1）标识符(占位符)：只要是一个合法的标识符即可，一般情况下，只使用一个大写字母表示泛型
例：public class Person<T>{} E(Element)  K(key)  V(value) T（Type）
2）泛型的类型与声明的类或接口不需要有任何的关系
3）泛型可以在类中充当任何的成员
4）泛型具体类型取决于实例化对象时传入的实际类型

3.3.4 泛型使用时的注意事项

1）泛型不能在类中声明静态属性、常量
final修饰的属性必须在声明的同时初始化，所以泛型不能声明常量
static修饰的属性是静态属性，先于对象，泛型类型取决于创建对象时传入的实际类型，所以泛型不能声明静态属性
综上所述：不能使用泛型声明静态属性、常量

2）泛型不能在类中初始化数组，但是可以声明数组
初始化数组时需要给元素进行分配空间,但是泛型类型不确定无法分配空间

3）在类中不能使用泛型声明参数个数相同的重载方法
当一个类中有两个泛型时，创建对象时，两个泛型使用相同类型替换，那么重载方法就是相同的方法（同名，参数列表也相同）

4）使用不同实际类型创建出的泛型类对象的引用不可以相互赋值

3.3.5 受限泛型(理解即可)

ArrayList<?>

1）<?>：表示任意类型
2）<? extends T>：表示T类或者T类的子类
3）<? super T>：表示T类或者T类的父类

#####3.6 泛型应用在集合上

泛型在集合中应用，表示的是集合中元素的类型

3.3Collections工具类

集合工具类，定义了除了存取以外的的集合常用方法。

方法名	描述
public static void reverse(List list);	反转集合中元素的顺序
public static void shuffle(List list);	随机重置集合元素的顺序
public static void sort(List list);	升序排序（元素类型必须实现Comparable接口）

四、Set接口

4.1Set接口

特点：无序，无下标，不可以重复

4.2常用方法

方法名	描述
add(E e)	确保此 collection 包含指定的元素（可选操作）。
addAll(Collection<? extends E> c)	将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
clear()	移除此 collection 中的所有元素（可选操作）。
contains(Object o)	如果此 collection 包含指定的元素，则返回true。
containsAll(Collection<?> c)	如果此 collection 包含指定 collection 中的所有元素，则返回 true。
equals(Object o)	比较此 collection 与指定对象是否相等。
isEmpty()	如果此 collection 不包含元素，则返回true。
iterator()	返回在此 collection 的元素上进行迭代的迭代器。
remove(Object o)	从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
removeAll(Collection<?> c)	移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
retainAll(Collection<?> c)	仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
size()	返回此 collection 中的元素数。
toArray()	返回包含此 collection 中所有元素的数组。

4.3 Set常用实现类

4.3.1 HashSet

此类实现Set接口，由哈希表支持。它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用null元素。

存储特点：相对无序存储，不可以存储相同元素（排重），通过哈希表实现的集合

4.3.2重写equals()

equals()方法是Object类中的方法，表示比较两个对象是否相等，若不重写相当于比较对象的地址，

为保证元素不重复，必须重写equals()

案例：设计一个Student类，重写equals方法，向一个HashSet集合中添加Student对象，
检验是否排重（若所有属性都相同，视为相同元素）

代码实现：

public class Student {
	private String name;
	private int age;
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	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 Animal() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
  	/*重写equals方法。当添加多个Student对象时，所有属性如果相同，则排重*/
	public boolean equals(Object obj) {
		if(this==obj){
            return ture;
        }
        if(obj==nul)
            return ture;
        if(this.getClass()!=obj.getClass()){
            return false;
        }
        Student s = (Student)obj;

		if(this.name.equals(s.name) && this.age.equals(s.age) && this.sex.equals(s.sex) && 				                       this.score.equals(s.score))
			return true;
			
		return false;
	}
}

4.3.3重写hashCode()

hashCode()是Object中的方法，每个对象的hashCode值是唯一的，所以可以理解成hashCode值表示这个对象在内存中的位置

HashSet集合排重时，需要判断两个对象是否相同，对象相同的判断可以通过hashCode值判断，所以需要重写hashCode()方法

代码实现：

public class Student {
  	private String name;
	private int age;
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	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 Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
  	/*重写hashCode()方法，单纯为了检查此方法是否可以实现排重效果，所以返回一个固定的值，使所有本类对象的hashCode值都是相同的*/
	public int hashCode() {
		 return this.name.hashCode() + this.age;
	}
}

同时重写hashCode和equals两个方法，可以实现元素的排重效果

代码实现：

public class Student {
	private String name;
	public Student(String name) {
		super();
		this.name = name;
	}
	public Student() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	@Override
  	//重写equals
	public boolean equals(Object obj) {
      	//先判断传入的参数对象是否是Student对象，若不是直接返回false
		if(obj instanceof Student) {
          	//若是，强转成Student对象，并比较属性的值
			Student s = (Student) obj;
			if(this.name.equals(s.name)) {
              	 //若属性的值相同，则返回true
				return true;
			}
		}
		return false;
	}
  	@Override
    public int hashCode(){
      	/*hashCode方法返回值是int类型，所以重写时需要找到int类型的数据返回，还要保证此方法的返回值与对象的所有属性都相关,所以返回姓名属性的hashCode*/
		return this.name.hashCode();
    }
}

五、Map接口

5.1概念

Map接口是将键（key）映射到值（value）的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

无序、无下标、键不可重复，值可重复

常用方法

方法名	描述
clear()	从此映射中移除所有映射关系（可选操作）。
containsKey(Object key)	如果此映射包含指定键的映射关系，则返回 true。
containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true。
equals(Object o)	比较指定的对象与此映射是否相等。
get(Object key)	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
isEmpty()	如果此映射未包含键-值映射关系，则返回 true。
keySet()	返回此映射中包含的键的 Set 视图。
put(K key, V value)	将指定的值与此映射中的指定键关联（可选操作）。
remove(Object key)	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
size()	返回此映射中的键-值映射关系数。

5.1.2 Map实现类 HashMap

基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序。

存储特点：
相对无序存储，元素以键值对形式存在，键不可以重复，值可以重复，元素整体排重，可以快速的通过键查找到所对应的值，通过哈希表实现的集合。

代码实现

public class TestHashMap {

	public static void main(String[] args) {
		
		HashMap<Integer,String> map = new HashMap<Integer,String>();
		
		map.put(0 , "Hello");
		map.put(1 , "World");
		map.put(2 , "A");
		map.put(3 , "B");
		map.put(4 , "C");
		map.put(5 , "D");
		map.put(6 , "E");
		map.put(0 , "Everyone");
		
		String s = map.remove(1);
		
		for (int i = 0; i < map.size(); i++) {
			if(map.containsKey(i)){
				System.out.println(map.get(i));
			}
		}
		System.out.println("移除的是" + s);
	}

}

六、迭代器

6.1什么是迭代器

Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。

6.2常用方法

方法名	描述
boolean hasNext()	如果有元素可以迭代访问，返回true
E next	返回迭代的下一个元素

6.3代码实现

public class Demo {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<>();
		map.put("aaa", 111);
		map.put("bbb", 222);
		map.put("ccc", 333);
		//将map转成一个Set集合
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		//遍历set
		Iterator<Map.Entry<String, Integer>> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

迭代的下一个元素 |

6.3代码实现

public class Demo {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<>();
		map.put("aaa", 111);
		map.put("bbb", 222);
		map.put("ccc", 333);
		//将map转成一个Set集合
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		//遍历set
		Iterator<Map.Entry<String, Integer>> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}