JAVA_11

---

JAVA容器

1.整体结构

2. list_有序可重复

1. list使用样例，大部分都是collection接口的方法

//有序、可重复
List list =new ArrayList();		//泛型
System.out.println(list.isEmpty());
List.add("高淇");
System.out.println(list);
System.out.printin(list.isEmpty());
List.add("高三");
list.add("高四");

System.out.println(list);
System.out.println("list的大小:"+list.size());
System.out.println("是否包含指定的元素:"+list.contains("高淇"));

list.remove( o:"高四");
System.out.println(list);

Object[] objs = list.toArray();
System.out.println("转化成0bject数组:"+ Arrays.toString(objs));

list.clear();
System.out.println(list);

2. ArrayList类、LinkedList类、vector类的区别

ArrayList:ArrayList底层是用数组实现的存储。特点:查询效率高，增删效率低，线程不安全。
LinkedList:LinkedList底层用双向链表实现的存储。特点:查询效率低，增删效率高，线程不安全。
Vector:Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”

3. set_无序不重复

1. set使用样例

//Set中不可重复的核心:equals()方法
public static void test02(){
	Emp e1 = new Emp( id: 1001ename:"张三");
	Emp e2 = new Emp( id: 1002,ename:"李四");
	Emp e3 = new Emp( id: 1001,ename:"王五");
	Set s= new HashSet();
	s.add(e1);s.add(e2);s.add(e3);
	//相当(equals()返回true)的元素不会再被加入!
	System.out.println(s);
}

class Emp {
	private int id;
	private string name;
	@0verride
	public boolean equals(Object o){
		if(this == o)return true;
		if(o == nullll getClass()!= o.getclass()) return false;
		Emp emp =(Emp)o;
		return id == emp.id;
	}
	@0verride
	public int hashcode(){
		return Objects.hash(id);
	}
	public Emp(int id, String ename){
		this.id = id;
		this.name= name;
	}

4. map

1. Map就是用来存储“键(key)-值(value)对”的。Map类中存储的“键值对”通过键来标识，所以“键对象”不能重复。
2. Map 接口的实现类有HashMap、TreeMap、HashTable、Properties等
3. HashMap与HashTable的区列
   HashMap:线程不安全，效率高。允许key或value为null。
   HashTable:线程安全，效率低。不允许key或value为null。
4. 泛型即简单限制容器的内容，例限制为String，这样只能向里面放入String，拿出来也是String。

//通过索引逸历List，适用list
for(int i=0;i<list.size();i++){
String temp =list.get(i)
System.out.println(temp);
}
//增强for循环(foreach),适用list、set
for(string temp:list){
System.out.println(temp);
}
//使用Iterator对象,适用list、set
for(Iterator<string> iter=list.iterator();iter.hasNext();){
String temp = iter.next();
System.out.println(temp);
}

//遍历键
Set<String> keys = map.keySet();
for(String temp:keys){
System.out.println(temp);
System.out.println(map.get(temp));
System.out.println(temp+"----"+map.get(temp))
}
//逸历值
Collection<String> values = map.values();
for(String temp:values){
System.out.println(temp)
}
//使用EntrySet逸历key、value
Set<Hap.Entry<String,String>> entrySet = map.entrySet()
for(Map.Entry e:entrySet){
System.out.println(e.getKey()+"===="+e.getValue());
}

5.泛型

1. 泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入。
2. 参数化类型，就是:

1、把类型当作是参数一样传递。
2、<数据类型>只能是引用类型。

3. 使用泛型的两个好处

1.代码可读性更好(不用强制转换)
2.程序更加安全(只要编译时期没有警告，运行时期就不会出现ClassCastException异常)

4. 泛型主要用于编译阶段，编译后生成的字节码class文件不包含泛型中的类型信息，涉及类型转换仍然是普通的强制类型转换。
   泛型主要是方便了程序员的代码编写，以及更好的安全性检测。
5. 容器中边遍历边删除，使用迭代器

List<String> list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("bad");
list.add("bag");
System.out.println(list);
//边遍历边删除，容器的size会发生变化;
for(int i=0;i<list.size();i++){
	String temp =list.get(i)
	if(temp.startsWith("b")){
		list.remove(i);
	}
	System.out.println("size:"+list.size());
	System.out.println(list);
}
//使用迭代器对象。他始终指向下一个元素，不关心容器整体的变化。
for(Iterator<String> iter=list.iterator();iter.hasNext();){
	String temp = iter.next();
	if(temp.startswith("b")){iter.remove();}
}