集合之List集合

1. Collection接口

1.1 集合框架的顶级接口
1.2 是Set和List的父接口
1.3 但不是Map的父接口

集合中只能添加引用类型数据

2. List接口

2.1 特点：

有序、元素可以重复

//1.list集合的特征：有序
		List ls=new ArrayList();
		ls.add("哈哈");
		ls.add("嘿嘿");
		ls.add("呵呵");
		ls.add("啊啊");
		
		for (Object object : ls) {
			System.out.println(object);
		}
		System.out.println("————————————————————");
		
		
		//2.list集合的特征：元素可以重复
		ls.add("哈哈");

2.2 遍历方式

2.2.1 下标
2.2.2 foreach(>=jdk1.5)
2.2.3 迭代器Iterator（hasNext()、 next()）

      //1.下标遍历
		for (int i = 0; i < ls.size(); i++) {
			System.out.println(ls.get(i));
		}
		
		System.out.println("——————————————————");
		
		//2.foreach循环
		for (Object object : ls) {
			System.out.println(object);
		}
		System.out.println("——————————————————");
		
		
		//3.迭代器遍历
//		Iterator iterator = ls.iterator();
//		while (iterator.hasNext()) {//是否还有下一个，（相当于在下标为-1的位置上问是否还有下标为0的，-1是做假设的一个下标），然后循环问下去，直至问完
//			Object next = iterator.next();//获取到下一个
//			System.out.println(next);
//		}
		
		//ListIterator是list独有的(且可以向上遍历，但要结合hasNext()同时使用才可以向上遍历)，set没有
		ListIterator listIterator = ls.listIterator();
		
		//Set set=null;//set没有SetIterator
		
		//(1)、向下遍历
		while (listIterator.hasNext()) {//是否还有下一个
			Object next = (Object) listIterator.next();//是否还有下一个
			System.out.println(next);
		}
		System.out.println("——————————————————");
		
		//(2)、向上遍历，但要结合hasNext()同时使用才可以向上遍历（相当于在下标为-1的位置上问是否还有下标为-2的，-1是做假设的一个下标，那肯定是没有的）
		//但如果向下遍历后再向上遍历就可以，这样就可以覆盖向下遍历的数据获取到最后一个下标，然后倒着遍历
		//向上遍历在项目中应用性不强
		while (listIterator.hasPrevious()) {//是否还有上一个
			Object previous = listIterator.previous();//是否还有上一个
			System.out.println(previous);
		}  

2.3 List优化：

即指定初始容量，以减少多次扩容
初始容量10,负载因子0.5（初始容量+初始容量*0.5）

public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
		
		//1.list集合的优化：list集合的底层就是个以object[]
		//list集合优化:即设置list的初始容量，以减少多次扩容
		List ls=new ArrayList(50);
		print(ls);	
		
		//list集合初始容量10
		//ls.add(1);
		//print(ls);
		
		//list集合负载因子0.5
		//list集合扩容后的大小：初始容量+初始容量*0.5
		for (int i = 1; i <= 11; i++) {
			ls.add(i);
			print(ls);
			
		}
	}
	/**
	 * 静态方法  属于类
	 * @throws SecurityException 
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	public static void print(List arrayList) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
		
		//反射 
		//1.获取类对象
		Class clazz = arrayList.getClass();
		
		//2.获取属性对象
		Field field = clazz.getDeclaredField("elementData");
		
		//3.打开属性访问限制
		field.setAccessible(true);
		
		Object[] arrs =(Object[])field.get(arrayList);
		System.out.println("数组的长度为："+arrs.length);
		
		
	}
		
	/**
	 * 实例方法  属于对象
	 */
	public void add() {
		
	}

2.4 List元素删除

1）、for循环
2）、迭代器删除

//list集合的删除:迭代器删除比for循环删除更便利
		List<String> ls=new ArrayList<String>();
		ls.add("哈哈");
		ls.add("嘿嘿");
		ls.add("呵呵");
		ls.add("啊啊");
		
		System.out.println(ls.size());
		//1.for循环删除
		//for循环这种删除不能完全删除掉所有元素，因为每次删除一个，集合的下标都会重新组合（即删除下标0的元素后，重新组合还会下标0，但下一轮删除是从下标1开始，所以0滞留了）
		/*for (int i = 0; i < ls.size(); i++) {
			ls.remove(i);
		}*/
		
		
		//一定要删除的话，就倒着删除
		/*for (int i = ls.size()-1; i >=0; i--) {
			ls.remove(i);
		}
		System.out.println("——————————————");
		System.out.println(ls.size());*/
	
		
		
		//2.迭代器删除
		Iterator iterator = ls.iterator();
		while (iterator.hasNext()) {
			iterator.next();
			iterator.remove();
		}
		System.out.println(ls.size());
    

3. 泛型

JDK1.5之后，以类型作为参数的类就叫泛型
作用：提高程序健壮性，简化代码
泛型的默认值是Object

4. 装箱、拆箱（案例：快递）

值类型->引用类型 装箱
引用类型->值类型 拆箱
jdk1.5之后引入了自动装箱及自动拆箱功能

public class Demo4 {
	public static void main(String[] args) {
		
		//手动装箱及手动拆箱
		//jdk1.5之前的要进行转换
		int a=10;
		Integer b=new Integer(a);//装箱
		int  c=b.intValue();//拆箱
		
		//jdk1.5之后引入了自动装箱及自动拆箱功能
		//自动装箱及自动拆箱
		int i=1;
		Integer j=2;
		
		//1.装箱:值类型->引用类型
		//i=j;
		//System.out.println(i);
		
		//2.拆箱:引用类型->值类型 
		j=i;
		System.out.println(j);
		
		
	}
		
}

5. ArrayList、LinkedList、Vector区别

ArrayList：以连续的数组结构存储数据，查询快（下标）、增删改慢，异步 线程不安全
LinkedList：以链表的结构存储数据，查询慢、增删改快 Vector：增删改查都慢，已过时,同步.线程安全

同步：排队进行，线程安全
异步：同时进行，线程不安全

6.案列：使用LinkedList完成一个堆栈MyStack

public class MyStack {
    	//弹夹
    	/**
    	 * 装弹（压栈）
    	 * @param obj 装弹对象
    	 */
    	public void push(Object obj){
    		ls.addFirst(obj); //每次都把子弹增加到第一颗，把原来的压到下面去
    	}
    
    	/**
    	 * 打枪（出栈）
    	 * @return 刚打出的子弹
    	 */
    	public Object pop(){
    		//方式二：
    //		Object obj = ls.getFirst();//取出第一颗子弹
    //		ls.removeFirst(); //移除第一颗子弹
    //		return obj;//返回刚刚打出的子弹
    		//方式一：
    		return ls.remove();
    	}
    
    	/**
    	 * 计算弹夹中子弹数量
    	 * @return 集合中子弹的数量
    	 */
    	public int size(){
    		return ls.size();
    	}
    
    	public static void main(String[] args) {
    
    		MyStack ms=new MyStack();
	
    		ms.push("a");//装第一颗子弹
    		ms.push("b");
    		ms.push("c");
    		ms.push("d");//装最后一颗子弹
    	
    		while(ms.size()!=0){//如果子弹数量不等于0，就一直循环打枪
	
    			System.out.println(ms.pop());
	
    		}
    	}
}
```**