集合复习（一）_arrays.new 一个新集和-CSDN博客

本文链接：https://blog.csdn.net/li_wei_song/article/details/44648163

概念

集合是可以存储不同类型的的数据并且可以动态存储的序列或者说是容器。

集合与数组的区别

1:数组既可以存储基本数据类型,又可以存储引用数据类型

集合只能存储引用数据类型(对象)

2:数组长度是固定的,不能自动增长

集合的长度的是可变的,可以根据元素的增加而增长

集合框架

Collection接口中有list和set，list有序，有索引，可以重复；set无序，无索引，不可重复

List的三个子类的特点
        ArrayList:
            底层数据结构是数组，查询快，增删慢。
            线程不安全，效率高。
        Vector:
            底层数据结构是数组，查询快，增删慢。
            线程安全，效率低。
        Vector相对ArrayList查询慢(线程安全的)
        Vector相对LinkedList增删慢(数组结构)
        LinkedList:
            底层数据结构是链表，查询慢，增删快。
            线程不安全，效率高。

jdk1.5版本的几个新特性

一，自动拆装箱

二，泛型

三，增强for循环

package cn.itcast.vector;

import java.util.ArrayList;

import cn.itcast.been.Student;

public class DemoFor {
	public static void main(String[] args) {
		//demo1();
		ArrayList<Student> list = new ArrayList<>();
		list.add(new Student("李四",23));
		list.add(new Student("李桶",26));
		list.add(new Student("李盆",25));
		list.add(new Student("李完",28));
		
		
		for (Student s : list) {//增强for循环
			
			System.out.println(s.getName()+" ,"+ s.getAge());
		}
	}

	private static void demo1() {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		for (String s: list) {//元素数据类型  变量名： 集合或数组
			System.out.println(s);
			
		}
	}
	
}

四，静态导入

package cn.itcast.list;

import static java.util.Arrays.sort;//静态导入
import static java.util.Arrays.toString;

public class Demo08_StaticImport {

	/*
	 静态导入:其实导入的是静态的方法,只要是静态的方法都可以用静态导入
	 */
	public static void main(String[] args) {
		int[] arr = {55,44,33,22,11};
		sort(arr);							//排序。静态导入后这里就不用写成Arrays.sort(arr);
		//System.out.println(toString(arr));	//数组转换成字符串并打印,和其他toString方法冲突
	}

}

五，可变参数

public class DemoKeBian {
	public static void main(String[] args) {
		int[] arr = {22,33,44}; 
		//print(arr);//将数组的地址值传给print方法
	}
	/*public static void print(int[] arr){//将数组参数传给方法
		for (int i : arr) {//遍历数组
			System.out.println(i);
		}
	}*///这两种参数能起到一样的效果但是可变参数功能强大可以接受地址传入也可接受值传入,其实就是可以变化的数组
	                // print{22,33,33,44};
	                // print();都可传入可变参数接受范围是0到无穷大
	public static void print (int x,int ...arr){//将可变参数传给方法
		for (int i : arr) {//遍历数组
			System.out.println(i);
		}
	}
	print(22,33,33,44);//给上下两个方法传值进行比较
	public static void print (int ...arr,int x){//上面不报错运行正常，
		                           //这里报错是因为intx接不到数据都被可变参数吃掉
		for (int i : arr) {
			System.out.println(i);
		}
	}
}

Collection集合的基本功能

package cn.itcast.text;

import java.util.ArrayList;
import java.util.Collection;

public class Text2 {
	
	public static void main(String[] args) {
		
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		//demo5();
		
	}

	private static void demo5() {
		Collection coll =new ArrayList();
		coll.add("a");                
		coll.add("b");
		coll.add("c");
		Object [] arr = coll.toArray();//集合转化成数组
		for (int i = 0; i < arr.length; i++) {//对数组进行遍历
			System.out.println(arr[i]);	
		}
		//System.out.println(arr);//不能直接打印会报：[Ljava.lang.Object;@feb48。需要遍历
	}

	private static void demo4() {
		Collection coll =new ArrayList();
		coll.add("a");                
		coll.add("b");
		coll.add("c");
		boolean b1 = coll.remove("a");//删除，如果有就返回true
		boolean b2 = coll.remove("d");//删除，如果没有就返回false
	}

	private static void demo3() {
		Collection coll =new ArrayList();
		boolean b2 = coll.isEmpty();//判断集合是否为空
		System.out.println(b2);
	}

	private static void demo2() {
		Collection coll =new ArrayList();
		coll.add("a");                
		coll.add("b");
		coll.add("c");
		coll.add("d");
		//boolean b1 = coll.equals("abcd");//此处报错是因为equals不是集合和元素的比较是集合和的比较
		//System.out.println(b1);
		
		Collection coll1 =new ArrayList();
		coll1.add("a");                
		coll1.add("b");
		coll1.add("c");
		coll1.add("d");
		//coll1.add("e");
		boolean b1 = coll.equals(coll1);//元素和元素的比较,元素一样顺序一致返回true
		System.out.println(b1);
	}

	private static void demo1() {
		Collection coll =new ArrayList();
		coll.add("a");                 //在集合中添加，只能添加一个
		coll.add("b");
		coll.add("c");
		coll.add("d");
		coll.add("e");
		coll.add("f");
		//coll.clear();//清空集合
		boolean b1 = coll.contains("a");//判断集合中是否包含元素。包含返回true
		boolean b2 = coll.contains("h");//不包含返回false
		System.out.println(coll);
		System.out.println(b1);
		System.out.println(b2);
	}

}

迭代器原理
迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的

public class Demo2Student {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Collection c = new ArrayList();     //定义集合对象，父类引用指向子类对象  ，类型提升，
		c.add(new Demo1Student("李四",23));
		c.add(new Demo1Student("李无",24));
		c.add(new Demo1Student("李六",24));
		c.add(new Demo1Student("李起",25));
		c.add(new Demo1Student("李把",26));
		c.add(new Demo1Student("李就",26));
		c.add(new Demo1Student("李是",27));
		c.add(new Demo1Student("李好",28));
		c.add(new Demo1Student("李和",29));
		c.add(new Demo1Student("李后",22));
		
		for (Iterator i = c.iterator(); i.hasNext();) {
			Demo1Student s = (Demo1Student)i.next();//向下转型
			System.out.println(s.getName()+ ","+ s.getAge());//获取对象中的姓名和年龄
		}
		
		System.out.println("-------------------------------------");//这两种形式同时使用可以看出for循环和while循环区别，for用完后释放初始化，while用完保存初始化
		Iterator i = c.iterator();                          //获取迭代器
		while(i.hasNext()){                          //判断集合中是否有元素
			//Demo1Student s = (Demo1Student)i.next();//向下转型
			//System.out.println(s.getName()+ ","+ s.getAge());//获取对象中的姓名和年龄
			System.out.println(i.next());
		}
	}


}

List集合中的几个功能

package cn.itcast.list;


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


@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo1_List {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		list.add("f");
		
		//list.set(1, "z");						//在指定位置修改
		List newList = list.subList(2, 4);		//截取子集合,包含头,不包含尾
		System.out.println(list);
		System.out.println(newList);
	}


	public static void demo4() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		
		//Object obj = list.remove(1);		//根据索引删除,返回被删除的对象
		//System.out.println(obj);
		System.out.println(list);
		
		boolean b1 = list.remove("b");		//根据对象删除
		System.out.println(b1);
		
		System.out.println(list);
	}


	public static void demo3() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Object obj = list.get(1);				//通过索引获取集合中的元素,如果索引不存在会抛出IndexOutOfBoundsException
		System.out.println(obj);
		
		int index = list.indexOf("b");			//通过对象获取索引
		System.out.println(index);
		
		int index2 = list.lastIndexOf("b");		//从后向前遍历,获取对象的索引
		System.out.println(index2);
	}


	public static void demo2() {
		List list1 = new ArrayList();
		list1.add("a");
		list1.add("b");
		list1.add("c");
		list1.add("d");
		
		List list2 = new ArrayList();
		list2.add("e");
		list2.add("f");
		list2.add("g");
		list2.add("h");
		
		list1.addAll(1, list2);				//在指定位置向调用的集合中添加集合
		System.out.println(list1);
	}


	public static void demo1() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		//list.add(1, "z");					//在指定位置添加元素
		list.add(4, "z");
		System.out.println(list);
	}


}

package cn.itcast.test;

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

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Test3_List {

	
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		
		//这种遍历只支持list集合,set集合不可以,因为set集合无索引
		for(int i = 0; i < list.size(); i++) {			
			System.out.println(list.get(i));				//根据索引获取值
		}
	}

}

ListIterator的特有功能

public static void main(String[] args) {
		//demo1();
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("world");
		list.add("d");
		list.add("e");
		
		/*Iterator it = list.iterator();
		while(it.hasNext()) {
			String str = (String)it.next();
			if(str.equals("world")) {
				list.add("javaee");			//这里会抛出ConcurrentModificationException并发修改异常
			}
		}*/
		
		ListIterator lit = list.listIterator();		//如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
		while(lit.hasNext()) {
			String str = (String)lit.next();
			if(str.equals("world")) {
				lit.add("javaee");	
				//list.add("javaee");
			}
		}
		System.out.println(list);
	}

	public static void demo1() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		
		ListIterator lit = list.listIterator();
		/*while(lit.hasNext()) {
			System.out.println(lit.next());
		}*/
		
		System.out.println("----------------------");
		while(lit.hasPrevious()) {						//倒着遍历
			System.out.println(lit.previous());
		}
	}

}

Vector类特有功能

public static void main(String[] args) {
		Vector v = new Vector();				//创建集合对象,List的子类
		v.addElement("a");
		v.addElement("b");
		v.addElement("c");
		v.addElement("d");
		
		//Vector迭代
		Enumeration en = v.elements();			//获取枚举
		while(en.hasMoreElements()) {			//判断集合中是否有元素
			System.out.println(en.nextElement());//获取集合中的元素
		}
	}

}

ArrayList去除集合中字符串的重复值的方式

public static void main(String[] args) {
		//demo1();
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		ArrayList newlist = getSingel(list);//调用方法getsingel
		System.out.println(newlist);         //将集合输出
	}
    /*
     * 明确返回值类型ArrayList
     * 明确参数列表ArrayList 
     */
	public static ArrayList getSingel(ArrayList list){
		ArrayList newlist = new ArrayList();//重新创建Arraylist对象
		Iterator it = list.iterator();//获取遍历器
		while(it.hasNext()){//判断老集合内是否有元素
			String s = (String)it.next();//向下转型
			if (!newlist.contains(s)) {//判断新集合中是否包含
				newlist.add(s);        //将元素添加到新集合中
			}
		}
		return newlist;            //返回新集合
	}

ArrayList去除集合中自定义对象元素的重复值的方式

public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add(new Student("李四",24));
		list.add(new Student("李四",24));
		list.add(new Student("李四",24));
		list.add(new Student("李四",24));
		list.add(new Student("查三",23));
		list.add(new Student("查三",23));
		list.add(new Student("查三",23));
		list.add(new Student("赵六",34));
		list.add(new Student("赵六",34));
		list.add(new Student("赵六",34));
		ArrayList newlist = getSingel(list);//调用getsingel方法
		System.out.println(newlist);//这种打印结果与原集合没有两样因为contains方法底部用的是equals方法需要将其重写
	}
    /*
     * 明确返回值类型ArrayList
     *明确参数列表ArrayList List*/
	public static ArrayList getSingel(ArrayList list){
		ArrayList newlist = new ArrayList();//创建新的集合对象
		Iterator it = list.iterator();//创建迭代器
		while(it.hasNext()){//判断集合中是否有元素
			Student s = (Student)it.next();//向下转型
			if(!newlist.contains(s)){//判断新集合中是否含有元素，如果不含 。。。。。写这步前要重写contains底部的equals方法
				newlist.add(s);//将新集合中不包含的元素添加到新集合中
			}
		}
		return newlist;//返回新集和
		
		
		
	}
	
	

}

LinkedList类特有功能

public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.addFirst("a");
		list.addFirst("b");
		list.addFirst("c");
		list.addFirst("d");						//在第一个位置添加
		//list.addLast("e");						//在末尾追加
		System.out.println(list);
		
		Object obj1 = list.getFirst();			//获取集合中的第一个元素
		System.out.println(obj1);
		Object obj2 = list.getLast();			//获取集合中的最后一个元素
		System.out.println(obj2);
		
		System.out.println(list);
		
		Object obj3 = list.removeFirst();		//删除集合中的第一个元素
		System.out.println(obj3);
		Object obj4 = list.removeLast();		//删除集合中的最后一个元素
		System.out.println(obj4);
		
		System.out.println(list);
		
	}

Arrays工具类的asList()方法的使用

package cn.itcast.vector;

import java.util.Arrays;
import java.util.List;

public class DemoAsList {
	public static void main(String[] args) {
		//int[] arr = {11,22,22,33,44};
		//List<int[]> li = Arrays.asList(arr);
		//System.out.println(li);//此处输出是[[I@155e0bc]因为此方法把整个数组当成一个对象，
		                        //与下面的字符串比较，所以aslist不能转基本数据类型，只能转化引用数据类型
		
		//基本数据类型可以用Integer进行转换
		Integer[] arr2 = {11,22,22,33,44};//Integer可以自动装箱，他把每一个数当成一个对象装箱
		List<Integer> li2 = Arrays.asList(arr2);
		System.out.println(li2);
		//String[] arr = {"44","55","66","77"};
		//List<String>list=Arrays.asList(arr);//调用Array中的aslist方法
		//System.out.println(list);
		
	}

}