collection集合框架01

 

 

1. Collection接口
  1.1 集合框架的顶级接口
  1.2 是Set和List的父接口
  1.3 但不是Map的父接口
  
  集合中只能添加引用类型数据

2. List接口
  2.1 特点：有序、对象可以重复 ？
  2.2 遍历方式 
    2.2.1 下标
    2.2.2 foreach(>=jdk1.5)
    2.2.3 迭代器Iterator（原理）
  2.3 List优化
      初始容量10,负载因子1.5

      指定初始容量
  2.4 List元素删除

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

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

5. ArrayList、LinkedList、Vector区别
   ArrayList：以连续的数组结构存储数据，查询快（下标）、增删改慢
   LinkedList：以链表的结构存储数据，查询慢、增删改快
   Vector：增删改查都慢，已过时
 

 

---

 

 

 

 代码段分析

package com.zking.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo {
public static void main(String[] args) {
		
		//1.UML:统一建模语言，例如：类图、用例图等等
		//2.Collection接口：是集合框架的顶级接口，是List和Set的父接口，但不是Map集合的父接口
		
		//3.List特点：不唯一、有序？？？？
		//1) 不唯一：不是唯一、可以添加重复元素
		//2) 有序：元素添加的顺序与输出的顺序一致
		//快捷键：Ctrl+Shift+O
		List lst=new ArrayList();
		lst.add("zs");
		lst.add("ls");
		lst.add("ww");
		lst.add("zs");
		
		//jdk1.8新特性
		lst.forEach(System.out::println);
		
		//4.List遍历方式（3种）
		//1) for下标
		System.out.println("---------1) for下标---------");
		for (int i = 0; i < lst.size(); i++) {
			System.out.println(lst.get(i));
		}
		//2) foreach
		System.out.println("---------2) foreach---------");
		for (Object object : lst) {
			System.out.println(object);
		}
		//3) iterator(迭代器)
		System.out.println("---------3) iterator(迭代器)---------");
		//获取迭代器
		Iterator it = lst.iterator();
		//hasNext():判断集合中的下一个元素是否存在，不移动下标（重点）
		//next():移动下标并取出当前元素
		//循环遍历
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		//5.List删除方式（3种+1）
		//1) for正向删除
		//2) for逆向删除
		//3) iterator（推荐）
		//4) clear 清空
		System.out.println("删除之前的List集合大小："+lst.size());
		//第一次删除：i=0 lst.remove(0) a 4
		//第二次删除：i=1 lst.remove(1) c 3
		//第三次删除：i=2  2<2
		int len=lst.size();
		for (int i = 0; i <len; i++) {
			lst.remove(0);
		}
		int lens=lst.size()-1;
		for (int i = lens; i>=0; i--) {
			lst.remove(i);
		}
		//获取迭代器
		ListIterator its = lst.listIterator();
		while(its.hasNext()) {
			//注：先移动下标，再删除元素
			its.next();
			its.remove();
		}
//		lst.clear();
		System.out.println("删除之后的List集合大小："+lst.size());
	}
}

 

---

  

package com.zking.util;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class Demo1 {
	/**
	 * List优化
	 * 核心概念：
	 * 1）初始化容量：10
	 * 2）负载因子（扩容比例）：1.5
	 * 3）计算公式：当前容器大小*负载因子（向下取整）
	 * 第一次：10*1.5=15
	 * 第二次：15*1.5=22
	 * 第三次：22*1.5=33
	 * @param args
	 */
	public static void main(String[] args) {
		List lst=new ArrayList(50);
		for (int i = 0; i < 50; i++) {
			lst.add(i);
			System.out.println(i);
			getLen(lst);
		}
	}
	
	public static void getLen(List lst) {
		try {
			//获取类对象
			Class<? extends List> cla = lst.getClass();
			//获取类中对应的属性
			Field field = cla.getDeclaredField("elementData");
			//设置访问权限
			field.setAccessible(true);
			//获取属性
			Object[] object = (Object[]) field.get(lst);
			//获取数组的长度
			System.out.println("当前List集合的大小为："+object.length);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

}

 

---

 

 

 

package com.zking.util;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo2 {
public static void main(String[] args) {
		
		//泛型：以类型作为参数的类叫做泛型
		//作用：提高程序的健壮性、简化代码
		//泛型的默认类型是Object
		//JDK1.5之后
		
		List<Integer> lst=new ArrayList<>();
		lst.add(new Integer(2));
		lst.add(1);
		lst.add(7);
		lst.add(8);
		
		//获取迭代器
		//Iterator it = lst.iterator();
		ListIterator<Integer> it = lst.listIterator();
		//循环遍历
		while(it.hasNext()) {
			//获取元素
			//Object val = it.next();
			//类型转换
			//int num=Integer.parseInt(val.toString());
			int num=it.next();
			//获取偶数
			if(num%2==0)
				System.out.println(num);
		}
		
		//装箱、拆箱  jdk1.5之前需要手动装拆箱（之后自动装拆箱）
		//装箱：值类型 -> 引用类型
		int a=1;
		Integer a1=new Integer(a);
		//拆箱：引用类型 -> 值类型
		Float f=new Float(1.5f);
		float floatValue = f.floatValue();
	}

}