java集合框架01

List 接口存储一组不唯一（可以重复），有序（插入顺序）的对象

01. ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

通过看ArrayList的源码得知：

    /**
     * Constructs an empty list with an initial capacity of ten.

           构造一个初始容量为十的空列表
     */
    public ArrayList() {
	this(10);  调用带参的构造 参数为10
    }









 ArrayList创建的时候，数组初始化长度为10！

List list=new ArrayList(-1);     这句话会运行错误！ 看源码得知！

    /**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param   initialCapacity   the initial capacity of the list 
     * @exception IllegalArgumentException if the specified initial capacity
     *            is negative
     */
    public ArrayList(int initialCapacity) {
	super();
        if (initialCapacity < 0)  参数小于0！会抛出异常信息
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	this.elementData = new Object[initialCapacity];
    }






List list=new ArrayList();   //初始化长度为10
list.add(1);

.....

list.add(11);   //这时候集合会自动扩容！返回一个新的数组长度 =原数组的长度*1.5+1

看源码得知！

 public void ensureCapacity(int minCapacity) {
	modCount++;
	int oldCapacity = elementData.length;
	if (minCapacity > oldCapacity) {
	    Object oldData[] = elementData;
	    int newCapacity = (oldCapacity * 3)/2 + 1;
    	    if (newCapacity < minCapacity)
		newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
    }








   


public class News {
	private int id;  //新闻编号
	private String title;  //新闻标题
	
	@Override
	public String toString() {
		return "新闻 [编号=" + id + ", 标题=" + title + "]";
	}
	
	public News() { //无参构造
		super();
	}
	public News(int id, String title) { //带参构造
		super();  
		this.id = id;
		this.title = title;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	
	public static void main(String[] args) {
		News news=new News();
		/*
		 * 直接输出对象 默认走Object类中的toString()
		 * News类中重写了这个toString() 就会走本类的！
		 */
		System.out.println(news);
	}
}














public class ArrayListTest {

	public static void main(String[] args) {
		
		List nums=new ArrayList();
		nums.add(1);
		nums.add(1);
		nums.add(1);
		nums.add(1);
		System.out.println(nums.size());
		
        /*
         * 创建一个ArrayList集合
         * 存储不唯一(允许重复)，有序的数据！
         * ArrayList是实现了可变大小的数组！
         * 随机访问和遍历的效率高！
         */
		List list=new ArrayList();
		//往集合中添加 元素（新闻对象）
		News news1=new News(1, "新闻1");
		News news2=new News(2, "新闻2");
		News news3=new News(3, "新闻3");
		list.add(news1);
		list.add(news2);
		list.add(news3);
		//01.打印出集合的长度
		System.out.println("新闻集合的大小："+list.size());
		//02.查询下标为2的新闻信息
		System.out.println(list.get(2));
		//03.删除下标为1的新闻
		list.remove(1);
		//04.通过对象删除
		list.remove(news3);
		//05.查询集合中是否包含news3
		System.out.println("是否包含news3===>"+list.contains(news3));
		//新增加一个对象
		list.add(new News(4, "新闻4"));
		//06.在指定的位置新增一个对象
		list.add(0, new News(5,"新闻5"));
		System.out.println("*************************");
		//打印新闻的标题
		for (int i = 0; i < list.size(); i++) {
			/*
			 * 根据集合的下标获取新闻的信息
			 * get（int index）返回值是Object
			 * 必须向下转型为News
			 */
			News news=(News) list.get(i);
			System.out.println(news.getTitle());
		}
		System.out.println("*************************");
		//07.把集合转换成数组
		Object[] array = list.toArray();
		for (int i = 0; i < array.length; i++) {
			News news=(News) array[i];
			System.out.println("新闻的标题是："+news.getTitle());
		}
		System.out.println("*************************");
		//08.通过for加强进行遍历
		for (Object object : list) {
			News news=(News) object;
			System.out.println("新闻的标题是："+news.getTitle());
		}
		System.out.println("*************************");
		/*
		 * 09.通过迭代器iterator接口
		 *      001.next():获取序列中的下一个元素
		 *      002.hasNext():检查序列中是否还有元素
		 *      003.remove():删除元素
		 */
		Iterator it = list.iterator();
		  //判断集合中是否有下一个元素
		while(it.hasNext()){
			News news=(News) it.next();
			System.out.println("新闻的标题是："+news.getTitle());
		}
		//10.清空整个集合
		list.clear();
		//11.判断集合是否为空
		System.out.println("集合是否为空==>"+list.isEmpty());
		System.out.println(list.size());  //  0
	}
}









  


02.LinkedList:采用链表存储方式。插入、删除元素时效率比较高
public class LinkedListTest {

	public static void main(String[] args) {
		//创建一个LinkedList集合
		LinkedList list=new LinkedList();
		//创建几个新闻对象
		News news1=new News(1, "新闻1");
		News news2=new News(2, "新闻2");
		News news3=new News(3, "新闻3");
		News news4=new News(4, "新闻4");
		//新增数据
		list.add(news1); //在一个位置
		list.addFirst(news2); //news2会顶替news1在集合中的位置  news1位于第2位
		list.addLast(news4); //news4在第三个位置
		list.add(news3);  //第4个位置
	    //遍历整个集合
		for (Object object : list) {
			News news=(News) object; //转换成新闻对象才能调用对应方法
			System.out.println("新闻的标题："+news.getTitle());
		}
		//通过indexOf(Object o) 获取对象在集合中的下标
		int index=list.indexOf(news4);
		list.remove(index);//根据下标删除对象
		//看是否还包含news4
		System.out.println("是否还包含news4==>"+list.contains(news4));
		//删除集合中的第一个元素
		list.removeFirst();
		for (Object object : list) {
			System.out.println(object); //不需要强制类型转换  默认走的是重写之后的toString()
		}
		//获取集合中的第一个元素
		News news=(News) list.getFirst();
		System.out.println("第一个元素的新闻标题："+news.getTitle());
		//获取集合中的最后一个元素
		News newsz=(News) list.getLast();
		System.out.println("最后一个元素的新闻标题："+newsz.getTitle());
	}
}                        



                                



ArrayList和LinkedList的区别

/*
		 * ArrayList和LinkedList的区别
		 * ArrayList:采用数组的形式来保存数据！这些数据被放在内存中开辟连续的空间！
		 *           每个数据的位置都有下标！ 
		 *           比如说：
		 *           现在集合长度为50！ 现在想删除下标为2的元素！
		 *           删除之后，底层还要做什么操作？
		 *           下标为2之后的元素都要前移？？
		 *           
		 *           现在想在下标为3的位置 新增 元素！
		 *           下标3的元素之后的数据全部后移？？
		 *           所以 新增，删除效率慢！
		 *           因为是数组结构，所以遍历，查询效率高！
		 *           
		 * LinkedList:链表式结构！存储在集合中的每个对象都存放在相互独立的空间！
		 *            比如说： 
		 *             现在集合长度为50！ 
		 *             第1个元素记录第2个元素的位置
		 *             第2个元素记录第3个元素的位置
		 *             。。。。
		 *             第49个元素记录第50个元素的位置
		 *             我们想删除第3个元素！
		 *             只需要让 第2个元素记录第4个元素的位置！
		 *             之后的元素有影响吗？  没有
		 *             
		 *             在第2个元素和第3个元素之间新增一个元素x
		 *             这时候只需要 第2个元素 记录x的位置
		 *             x记录第三个元素的位置
		 *             新增，删除效率高！
		 *             因为没有下标，所以查询遍历的效率低！
		 * 
		 */











       set集合

public class SetTest {
	public static void main(String[] args) {
		/*
		 * Set接口存储的是唯一（不能重复），无序（新增，删除，查询）对象的集合！
		 * HashSet是Set常用的实现类
		 * Set存放的是对象的引用
		 */
		//创建一个Set集合
		Set s=new HashSet();
		//给集合赋值
		s.add("");    //空串
		s.add(null);  //空值
		s.add(new String("abc"));
		System.out.println(s.size());  // 3
		
		Set set=new HashSet();
		set.add(new News(1, "新闻1"));
		set.add(new News(2, "新闻2"));
		set.add(new News(3, "新闻3"));
		System.out.println(set.size()); //3
		for (Object object : set) {
			System.out.println(object);
		}
	
		Set set1=new HashSet();
		set1.add(new String("abc"));
		set1.add(new String("abc"));
		set1.add(new String("abc"));
		System.out.println(set1.size()); //1
		
		String  a ="abc";
		String  b =new String("abc");
		String  c =new String("abc");
		System.out.println(a==b);  //false
		System.out.println(c==b); //false
		//具有相同内容的String对象，hashCode是一致的！
		System.out.println(b.hashCode()==c.hashCode());  //T
		
		String str1="a";
		String str2=new String("a");
		System.out.println(str1==str2); //false  内存地址不一样
		System.out.println(str1.equals(str2)); //true  内容一样
		System.out.println(str1.hashCode()==str2.hashCode()); //T
	}
}







           public class TreeTest {
	public static void main(String[] args) {
		/*
		 * 1. HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key
         * 2. Map的key和Set都有一个共同的特性就是集合的唯一性.TreeMap更是多了一个排序的功能.
         * 3. hashCode和equal()是HashMap用的, 因为无需排序所以只需要关注定位和唯一性即可.
         * 4. 由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较.
		 */
		Set set1=new HashSet();
		set1.add("z");
		set1.add("a");
		set1.add("y");
		set1.add("b");
		for (Object object : set1) {
			System.out.println(object);
		}
		
		System.out.println("*******************");
		TreeSet set2=new TreeSet();  //自动排序
		set2.add("z");
		set2.add("a");
		set2.add("y");
		set2.add("b");
		for (Object object : set2) {
			System.out.println(object);
		}
	}
}







map

public class MapTest {
	public static void main(String[] args) {
		/*
		 * Map 是一个键值对的集合 有  key和 value
		 * 通过key拿到value的值
		 * Set中的add()默认底层走的是Map的put()
		 * 所以key是不允许重复的！
		 * 也是先判断对象的hashCode，之后equals比较！
		 */
		Map m=new HashMap();
		m.put("1", "嘘");  
		m.put("1", "嘘");
		m.put("1", "嘘");
		m.put(new String("1"), "嘘");
		System.out.println(m.size()); // 1
		System.out.println("*************************");
		
		/*
		 * 在集合中  不存在 基本数据类型
		 * 基本数据类型不是类！
		 * 只能使用基本数据类型的封装类！
		 */
		Map map=new HashMap();  
		News news3=new News(3, "新闻3");
		//向集合中增加数据
		map.put("1", new News(1, "新闻1"));  //这里的  "1" 是String
		map.put(2, new News(2, "新闻2"));   //这里的2  是    Interger
		map.put(3, news3);
		map.put(4, new News(4, "新闻4"));
		System.out.println("集合的大小："+map.size());   // 4
		//通过map集合中的key取得对应的value
		News  news = (News) map.get("1");
		System.out.println(news);
		//根据key删除指定的对象
		System.out.println("删除的返回值:"+map.remove(4));
		//判断是否存在某个key
		System.out.println("是否有某个key："+map.containsKey(4));
		//判断是否存在某个value
		System.out.println("是否有某个value："+map.containsValue(news3));
		//得到所有key的集合
		Set keySet = map.keySet();
		for (Object object : keySet) {
			System.out.println(object);
		}
		//返回所有values的集合
		Collection values = map.values();
		for (Object object : values) {
			System.out.println(object);
		}
	}
}