Java集合详细解(一)

Java集合详解(一)

集合和数组的区别?

共同点:集合和数组都是属于"容器",存储元素
不同点:
	1)长度区别
		数组:长度固定
		集合:长度可变
	2)存储数据类型的区别
		数组:可以存储基本数据类型,也可以存储引用数据类型
		集合:只能存储引用数据类型
	3)存储元素的区别
		数组:只能存储同一种类型的元素
		集合:可以存储任意类型的元素(类型:引用类型)

Collection集合的遍历方式

1.Object[] toArray()
2.Iterator iterator():Collection集合的专有遍历方式

迭代器注意事项(在Java集合详解三中进行详细说明)

1.Object next()获取当前集合的元素(),不能使用多次,使用一次即可,获取所有元素信息
2.能使用for循环,不推荐(因为以后集合中元素可能不知道个数,使用while循环)

什么是泛型

格式:<数据类型:引用数据类型>
泛型的特点:将集合的类型在创建的时就明确,保证集合操作的安全性!
泛型的好处:
	1)避免了强制类型转换
	2)将运行时期异常提前到了编译时期(没有加入泛型之前,程序存在安全隐患,出现类型不配:ClassCastException:属于运行时期异常!)
	3)解决了黄色警告线问题
	4)提高了程序的安全性!
泛型的引用场景:
	1.可以定义在类上,如:public class Tool<T>{}
	2.可以定义在方法上,如:public void tool<T>(){}
	3.可以定义在接口上,如:interface Tool<T>{}

泛型的高级通配符

<?> 当前Object类型/任意Java类型(自定义/jdk提供...)
<? extends E>:向下限定:E类型以及它的子类 
<? super E>:向上限定:E类型以及它的父类

List集合

List集合继承Collection集合,可以允许元素重复
有序性:存取和取出一致

List集合的遍历方式

/*
1.Collection集合的方法Object[] toArray()
2.Collection集合的迭代器Iterator iterator()
3.istIterator<E> listIterator():List集合的专有遍历方式 :列表迭代器
4.size()+Object get(int index):普通for循环
5.增强for循环
格式:for(数据类型 变量名 : 数组对象/集合对象(使用最多)){
  			输出变量名即可
  	}
*/
public class ForeachTest {
	
	public static void main(String[] args) {
		//创建一个List集合对象
		List<Student> list = new ArrayList<Student>() ;//new ArrayList<Student>() :jdk7以后:泛型推断,建议和前面集合泛型保持一致
		
		//创建几个学生对象
		Student s1 = new Student("文章", 35) ;
		Student s2 = new Student("马伊琍", 44) ;
		Student s3 = new Student("姚笛", 28) ;
		Student s4 = new Student("黄晓明", 35) ;
		Student s5 = new Student("邓超", 37) ;
		
		//添加
		list.add(s1) ;
		list.add(s2) ;
		list.add(s3) ;
		list.add(s4) ;
		list.add(s5) ;
		
		//方式1
		Object[]  objs = list.toArray() ;
		for(int x = 0 ; x < objs.length ; x ++) {
			
			Student s = (Student)objs[x] ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("---------------------------------");
		
		//方式2:Collection的迭代器
		Iterator<Student> it = list.iterator() ;
		while(it.hasNext()) {
			Student s = it.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		System.out.println("--------------------------------");
		
		//方式3:list get方法和size()集合
		for(int x = 0 ; x < list.size() ; x ++) {
			Student s = list.get(x) ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("-------------------------------");
		
		//方式4:列表迭代器
		ListIterator<Student> lit = list.listIterator() ;
		while(lit.hasNext()) {
			Student s = lit.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("-------------------------------");
		//增强for循环
		for(Student s : list) {
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
public class Student {
	
	private String name ;
	private int age ;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

List集合如何去重?

/*
方式一:
1.创建一个新的集合,存储重复元素
2.遍历List集合,获取到每一个元素
3.使用contains()方法判断集合是否存在这个元素
*/
public class Test {
	
	public static void main(String[] args) {
		
		//创建一个List集合
		List<String> list = new ArrayList<String>() ;
		
		//给里面添加重复的字符串元素
		list.add("hello") ;
		list.add("world") ;
		list.add("hello") ;
		list.add("java") ;
		list.add("hello") ;
		list.add("javaee") ;
		list.add("javaee") ;
		list.add("android") ;
		list.add("android") ;
		list.add("R") ;
		list.add("go") ;
		
		//创建一个新的集合
		List<String> list2 = new ArrayList<String>();
		
		//遍历list集合,获取到每一个元素
		Iterator<String> it = list.iterator() ;
		while(it.hasNext()) {
			String s = it.next() ;
			
			//使用集合判断是否存在这个元素s
			if(!list2.contains(s)) {
				//当前元素在第二个集合中不包含,不重复,添加到集合中
				//将这个元素存储新集合中
				list2.add(s) ;
			}
		}
		
		//只需要遍历List2
		Iterator<String> it2 = list2.iterator() ;
		while(it2.hasNext()) {
			String s = it2.next() ;
			System.out.println(s);
		}
	}
}
/*
方式二:
1.创建一个新的集合,存储重复元素
2.使用选择排序的思想特点进行比较,如果使用0角标对应的元素依次和后面角标对应的元素进行比较,如果后面的元素重复了,则将该角标对应的元素从集合中删除,角标--
3.遍历集合
*/
public class Test2 {
	
	public static void main(String[] args) {
		//创建一个List集合
		List<String> list = new ArrayList<String>() ;
		
		//给里面添加重复的字符串元素
		list.add("hello") ;
		list.add("world") ;
		list.add("hello") ;
		list.add("java") ;
		list.add("hello") ;
		list.add("javaee") ;
		list.add("javaee") ;
		list.add("android") ;
		list.add("android") ;
		list.add("R") ;
		list.add("go") ;
		/*
		 * 利用选择排序思想的特点
 		 *使用0角标对应的元素依次和后面角标对应的元素对比,如果后面元素重复了,则将
 		 * 该角标对应的元素从集合中删除,角标--
		 * */
		for(int x = 0 ; x < list.size()-1 ; x ++) {
			for(int y = x +1 ; y < list.size() ; y ++) {
				//如果后面的和前面的元素相等,删除后面的元素
				if(list.get(y).equals(list.get(x))) {
					list.remove(y) ;
					y -- ;
				}
			}
		}
		//集合遍历
		Iterator<String> it = list.iterator() ;
		while(it.hasNext()) {
			String s = it.next() ;
			System.out.println(s);
		}
				
	}
}

ArrayList,LinkedList,Vector的区别

ArrayList:底层数据结构是可变数组结构: 查询快,增删慢,从线程角度考虑,线程不安全,不同步但是执行效率高!
LinkedList:底层数据结构是链接列表,查询慢,增删快,线从线程角度考虑:线程不安全,不同步但是执行效率高!
Vector:底层数组结构:查询快,增删慢,从线程角度考虑:线程安全,同步的,但是执行效率比较低!