java基础-day15-泛型.集合(一)ArrayList .LinkedList. HashSet

泛型

标志是 <> 通常配合集合一起使用
好处： 1. 约束集合元素的类型，进行安全检查，把错误显示在编译期
2. 代码通用性更强

类型安全检查

import java.util.ArrayList;
public class test1 {
	public static void main(String[] args) {
		int[] a = new int[3];
		//1、泛型就想模拟  数组，在编译时期，就检查数据的类型有没有符合要求
		//a[0] = 9.9 ;
		//a[1] = "jack" ;
		  a[2] = 10 ;			
		//创建集合
		//2、来意：是约束集合中的元素的  类型。
		//ArrayList list = new ArrayList();//没有约束
		//3、泛型中，只能写 引用类型，不能是基本类型。
		ArrayList<Integer> list = new ArrayList<>();//有约束		
		//向集合中存放元素
		//4、在编译期就会报错，提前了报错时机。
		//list.add(9.9);   //报错，不符合泛型的类型检查。
		//list.add("rose");   //报错，不符合泛型的类型检查
		list.add(10);		
		}	
}

foreach循环
语法： for(数据的类型 变量名 : 要遍历的数据)

代码通用性更强

public class test2 {
	public static void main(String[] args) {
		Integer[] a = {1,2,3,4,5};
		Double[] b = {1.1,2.2,3.3,4.4,5.5};
		String[] c = {"h","e","l","l","o"};
		print(a);
		print(b);
		print(c);
	}
	//1、泛型可以使用在类(接口)上，也可以使用在方法上(返回值前+参数列表)
	//2、约束了参数类型是泛型类型
	//普通for循环 foreach ：效率上foreach > 普通for 语法上foreach更简洁
	//foreach循环 
	//语法： for(数据的类型 变量名 : 要遍历的数据)
	public static <E> void print(E[] e) {
		for(E c:e) {
			System.out.println(c);
		}
	}
	//传统方式通过重载多态实现，方法同名，参数类型不同。
//	public static void print(Integer[] a) {
//		for(Integer c:a) {
//			System.out.println(c);
//		}
//	}
//	public static void print(Double[] b) {
//		for(Double c:b) {
//			System.out.println(c);
//		}
//	}
//	public static void print(String[] c) {
//		for(String s:c) {
//			System.out.println(s);
//		}
//	}
}

集合

存放多个数据？ 数组
数组的缺点： 只能存放相同类型数据，长度不可变，遍历方式单一
所以产生了集合

Collection接口

Collection是根接口。

常用方法

boolean add(E e)；             添加元素。
boolean addAll(Collection  c)；把小集合添加到大集合中 。
boolean contains(Object o)；   如果此 collection 包含指定的元素，则返回 true。 
boolean isEmpty();             如果此 collection 没有元素，则返回 true。 
Iterator<E> iterator();        返回在此 collection 的元素上进行迭代的迭代器。 
boolean remove(Object o);      从此 collection 中移除指定元素的单个实例。
int size();                    返回此 collection 中的元素数。
Objec[] toArray();             返回对象数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

//这个类用来测试 Collection 接口
public class test3 {
	public static void main(String[] args) {
		// 1、创建对象
		Collection<String> col = new ArrayList();
		// 2、常用方法
		col.add("jack");// 添加元素
		col.add("rose");
		col.add("hanmeimei");
		// col.clear();//清空集合
		System.out.println(col.contains("jack"));//判断集合中是否包含指定元素
		System.out.println(col.equals("韩梅梅"));//判断集合是否和指定元素相等
		System.out.println(col.hashCode());//返回集合对象在内存中的哈希码值
		System.out.println(col.isEmpty());//判断集合是否为空
		System.out.println(col.remove("rose"));//返回是否删除成功
		System.out.println(col.size());//获取集合的长度
		System.out.println(   Arrays.toString(  col.toArray()  )   );//把集合转成Object[]
		// 集合间的操作
		Collection<String> col2 = new ArrayList();
		col2.add("1");
		col2.add("2");
		col2.add("3");
		System.out.println(col.addAll(col2));//向col集合中添加col2集合的元素
		System.out.println(col.containsAll(col2));//判断col中是否包含col2的元素
		//System.out.println(col.removeAll(col2));//删除col2的元素
		//System.out.println(col.retainAll(col2));//删除col集合的元素
		// 迭代器：迭代/遍历集合中的元素
		Iterator it = col.iterator();
		while( it.hasNext()  ) {//hasNext()判断集合中有下一个元素吗
				System.out.println(  it.next()  ); //next()获取遍历到的元素
		}	
	}
}

List 接口

有序的Collection，此接口的用户可以对列表中每个元素的插入位置进行准确的控制，用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素
特点：元素都有索引，元素可以重复，元素有序
常用方法：

1. 从 Collection接口继承过来的方法
2. List 接口特有的方法

 void add(int index, E element)
 boolean addAll(int index, Collection<? extends E> c)  在列表的指定位置插入指定元素（可选操作）

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

package test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class test4 {
	public static void main(String[] args) {
		//1、创建对象
		List<String> list  = new ArrayList();		
		//2、常用方法
		//从Collection接口继承过来的方法  - 略，同Test2_Collection.java。
		list.add("xiongda");
		list.add("xionger");
		list.add("guangtouq");
		list.add("xionger");
		list.add("guangtouq");
		//List接口特点：元素都有序   +  允许存放重复元素   
		System.out.println(list);//[xiongda, xionger, guangtouq]
		System.out.println();
		//3、List接口的特有方法---都是可以按照索引操作的方法
		System.out.println(list);
		list.add(3,"钢铁侠");//在指定下标处添加元素
		System.out.println(list);
		System.out.println(   list.get(2)  );//获取指定下标对应的元素
		System.out.println(   list.indexOf("xionger")  );//获取指定元素  第一次 出现的 下标值
		System.out.println(   list.lastIndexOf("guangtouq")  );//获取指定元素  最后一次 出现的 下标值
		System.out.println(   list.remove(1)  );//删除指定下标的元素，并返回
		System.out.println(   list.set(0,"hanmeimei") );//把指定下标  的元素  替换成指定元素
		System.out.println(list);
		List<String> newList = list.subList(1, 3);//截取子List，含头不含尾[1,3)
		System.out.println(newList);
		List<String> list2  = new ArrayList();
		list2.add("99");
		list2.add("98");
		list2.add("97");
		System.out.println(  list.addAll(2, list2)    );//在指定下标处  添加集合
		System.out.println(list);
		//4、迭代器
		//普通for循环  for( 1; 2; 3){ ?  }
		for(int i = 0 ; i< list.size()   ; i++) {
			System.out.println(  list.get(i) );//根据下标i获取元素
		}
		//foreach
		for( String str : list ) {
			System.out.println(str);
		}
		//继承Collection接口iterator()
		Iterator<String> it = list.iterator() ;
		while(  it.hasNext() ) {//hasNext() 判断有没有下个元素
			String s = it.next();//next()获取元素
			System.out.println(s);
		}
		//Collection接口 iterator()  ---      返回值 Iterator (父接口)
		//List接口           listIterator()  ---返回值  ListIterator(子接口)--继承了父接口的所有功能的同时，又有功能扩展
		ListIterator<String> it2 = list.listIterator();
		while( it2.hasNext() ) {  // 判断后面有没有元素
			String str = it2.next() ;//获取元素
			System.out.println(str);
		}		
	}
}

ArrayList

特点：
底层维护了一个数组，默认初始容量是10。
初始容量不够会自动按照1.5倍的方式扩容
ArrayList底层维护很多操作的方法，本质上就是对数组的操作。
适合用于查询多增删少的场景。

LinkedList

双向链表，两端效率高。底层维护了一个链表结构,适用于增删多而查询少的场景。
常用方法：
1.继承 List 接口的方法
2.特有方法

void addFirst(E e)       将指定元素插入此列表的开头。
void addLast(E e)        将指定元素添加到此列表的结尾。
E getFirst()             返回此列表的第一个元素。
E getLast()              返回此列表的最后一个元素 
E removeFirst()          移除并返回此列表的第一个元素
E removeLast()     	 移除并返回此列表的最后一个元素
boolean offer(E e)  	 将指定元素添加到此列表的末尾（最后一个元素）
boolean offerFirst(E e)  在此列表的开头插入指定的元素
boolean offerLast(E e)   在此列表末尾插入指定的元素
E peek()                 获取但不移除此列表的头（第一个元素）
E peekFirst()            获取但不移除此列表的第一个元素；如果此列表为空，则返回 null
E peekLast()             获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null
E poll()                 获取并移除此列表的头（第一个元素）
E pollFirst()            获取并移除此列表的第一个元素；如果此列表为空，则返回 null
E pollLast()             获取并移除此列表的最后一个元素；如果此列表为空，则返回 null

import java.util.LinkedList;
public class test5 {
	public static void main(String[] args) {
		LinkedList<Integer> list = new LinkedList<>();
		//特点：和List一样，元素有序，可以重复
		list.add(100);
		list.add(200);
		list.add(300);
		list.add(null);
		list.add(null);
		list.addFirst(0);//添加首元素
		list.addLast(99);//添加尾元素
		System.out.println(list.getFirst());//获取首元素
		System.out.println(list.getLast());//获取尾元素
		System.out.println(list.removeFirst());//移除首元素
		System.out.println(list.removeLast());//移除尾元素
		System.out.println(list);
	}
}

Set 接口

特点：元素无序，不可重复，没有索引
常用方法： 同Collection接口一样

HashSet 实现类

特点： 此类实现 Set 接口，由哈希表/散列表（实际上是一个 HashMap 实例）支持
它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素
构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75

import java.util.HashSet;
import java.util.Set;
public class test6 {
	public static void main(String[] args) {
		Set<Integer> set = new HashSet<>();
		set.add(10);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);
		set.add(null);
		set.add(4);
		set.add(5);
		System.out.println(set);//[null, 2, 3, 4, 5, 10]
	}
}