java程序员从笨鸟到菜鸟之(二十七)集合之Jdk5以后新特性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package org.westos.Jdk5_news;

import java.util.ArrayList;
import java.util.Iterator;

public class ForDemo {
	
	public static void main(String[] args) {
		System.out.println("int数组普通for循环遍历---------------------");
		//定义一个数组,静态初始化
		int[] arr = {11,22,33,44,55} ;
		//普通for循环的遍历
		for(int x = 0 ; x < arr.length ; x ++){
			System.out.println(arr[x]);
		}
		
		System.out.println("int数组增强for循环遍历---------------------");
		//使用增强for遍历
		for(int i :arr){
			System.out.println(i);
		}
		//思考：增强for循环代码简单，但是执行速率呢？(有机会了看一看)
		
		
		System.out.println("String数组增强for循环遍历-------------------");
		//定义一个字符串数组,并遍历
		String[] strArray = {"hello","world","java"};
		for(String s : strArray){
			System.out.println(s);
		}
		
		
		System.out.println("集合的增强for循环遍历-------------------");
		//创建ArrayList集合对象,添加并遍历元素
		ArrayList<String> array = new ArrayList<String>() ;
		//添加元素
		array.add("hello") ;
		array.add("world") ;
		array.add("java") ;
		
		/*
		使用增强for遍历该集合
		for(String s :array){
			//需求：判断当前集合中是否有"world",如果有就添加元素
			//获取到每一个元素
			//出现异常--java.util.ConcurrentModificationException
			//理解上：理解为一个Iterator迭代器
			if("world".equals(s)){
				array.add("javaee") ;
			}
		}
		*/
		//为防止出现java.lang.NullPointerException：空指针异常--做非空判断
		if(array!=null){
			//增强for循环
			for(String s:array){
				System.out.println(s);
			}
		}
		
	}
}

1
2
3
4
5
6
7
String[] str = new String[3] ;
str[0] = "hello" ;
str[1] = "world" ;
str[2] = 100 ;
 for(String s:str){
  System.out.println(s);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package org.westos_01;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo2 {
	
	public static void main(String[] args) {
		
		//创建一个ArrayList集合对象
		ArrayList<String> array = new ArrayList<String>() ;//泛型
		/*
		 * jdk7特性:泛型推断
		 * 前面声明了集合存储元素的类型，后面可以不添加
		 * 建议:后面永远给出类型！！！
		 * 
		 */
		
		//给集合中添加元素
		array.add("hello") ;
		array.add("world") ;
		array.add("java") ;
		
		//获取迭代器对象并遍历
		Iterator<String> it = array.iterator() ;
		//遍历
		while(it.hasNext()){
			//好处：不用强制类型转换了
			String s = it.next() ;
			System.out.println(s);
		}
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package org.westos_02;

public class ObjectTool {
	
	private Object obj ;
	
	//获取
	public Object getObj(){
		return obj ;
	}
	
	//设置
	public void setObj(Object obj){//Object obj = new Integer(27) ; //向上转型
		this.obj = obj ;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package org.westos_02;
/**
 * 没有泛型时，向上转型是不会出现问题的，但是向下转型的时候，由于隐藏了类型转换，导致出现错误!
 */
public class ObjectToolDemo {
	
	public static void main(String[] args) {
		
		//创建ObjectTool对象
		ObjectTool ot = new ObjectTool() ;
		//设置数据
		ot.setObj(27) ;//Object obj = new Integer(27):向上转型
		//获取
		Integer i = (Integer) ot.getObj() ;//向下转型
		System.out.println("年龄是:"+i);
		
		
		ObjectTool ot2 = new ObjectTool() ;
		//设置
		ot2.setObj("高圆圆") ;//Object obj = new String("高圆圆") ;
		//获取
		String str = (String) ot2.getObj() ;//类型转换了:向下转型:隐藏了类型转换
		System.out.println("姓名是:"+str);
		
		System.out.println("-------------------------------");
		
		ObjectTool ot3 = new ObjectTool() ;
		ot3.setObj("邓超") ;
		//java.lang.ClassCastException
		Integer ii = (Integer) ot3.getObj() ;//强制类型转换的接收类型不匹配----程序不安全
		System.out.println("姓名是:"+ii);
	}
}	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package org.westos_03;

public class ObjectTool<T> {
	
	private T obj;
	
	//获取
	public T getObj(){
		return obj ;
	}
	
	//设置
	public void setObj(T obj){
		this.obj = obj ;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package org.westos_03;

public class ObjectToolDemo {
	
	public static void main(String[] args) {
		
		//创建ObjectTool<T>对象
		ObjectTool<String> ot = new ObjectTool<String>() ;
		//设置数据
		ot.setObj("高圆圆") ;
		//获取数据
		//编译都通过不了
//Integer i = ot.getObj() ; 由于给类上加入了泛型,在实际测试中,给定了数据类型,获取数据的时候就必须应该类型来接收,否则不匹配
		String name = ot.getObj() ;
		System.out.println("姓名是:" +name);
		
		//创建对象
		ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
		//设置数据
		ot2.setObj(27) ;
		
		//获取数据
//String s = ot2.getObj() ;
		Integer i = ot2.getObj() ;
		System.out.println("年龄是:"+i);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package org.westos_04;

//在工具类中定义几个成员方法
/*public class ObjectTool<T> {
	
	//形式参数是String
	public void show(String s){
		System.out.println(s);
	}
	
	//形式参数是Integer类型
	public void show(Integer i){
		System.out.println(i);
	}
	
	public void show(Boolean b){
		System.out.println(b);
	}
	
	public void show(T t){
		System.out.println(t);
	}
代码的冗余度比较高	
}*/


public class ObjectTool{
	
	//将泛型定义在方法上，根据传入的类型，调用相应的输出
	public <T> void show(T t){
		System.out.println(t);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package org.westos_04;

//测试类
public class ObjectToolDemo {

		public static void main(String[] args) {
			
                       /* 创建工具类对象
			ObjectTool ot = new ObjectTool() ;
			ot.show("hello") ;
			ot.show(100) ;
			ot.show(true) ;*/
			
		     /*	ObjectTool<String> ot1 = new ObjectTool<String>() ;
			ot1.show("hello") ;
			
			ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
			ot2.show(100) ;
			
			ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>() ;
			ot3.show(true) ;*/
			
			//泛型可以定义在方法上吗? ---OK---public <T> void show(T t){}
			
			//创建工具类对象
			ObjectTool ot = new ObjectTool() ;
			ot.show("hello") ;
			ot.show(true) ;
			ot.show(100) ;
		}
}

1
2
3
4
5
6
//把泛型定义在接口上
public interface Inter<T> {

	public abstract void show(T t) ;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package org.westos_04;

//第一种情况:接口的子实现类已经知道传递的是什么数据类型
/*public class InterImpl<String> implements Inter<String> {

	@Override
	public void show(String t) {
		System.out.println(t);
	}

}*/


//第二种情况:接口的子实现类在实现接口的时候,不知道具体的数据类型是什么
//在测试类的时候,传入具体数据类型

//面向接口编程

//JavaEE---Sping框架的AOP---面向切面编程
public class InterImpl<T> implements Inter<T>{

	@Override
	public void show(T t) {
		System.out.println(t);
	}
	
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package org.westos_04;

public class InterDemo {

	public static void main(String[] args) {
		//创建接口对象
		//第一种情况的测试
		Inter<String> i = new InterImpl<String>() ;
		i.show("hello") ;
		
		System.out.println("-----------------------------");
		
		//第二种情况:
		Inter<Integer> i2 = new InterImpl<Integer>() ;
		i2.show(27) ;
		
		Inter<String> i3 = new InterImpl<String>() ;
		i3.show("高圆圆") ;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package org.westos_02;

public class Student {
	
	private String name ;
	private int age ;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	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;
	}
	
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package org.westos_02;

import java.util.ArrayList;

/**
 * 假设有一个Java班,看成一个容器,这个容器里面有很多学生
 * ArrayList<Student>,但是又不止一个Java班,
 * 大的集合:ArrayList<ArrayList<Student>>
 * 集合的嵌套遍历
 * @author Apple
 */
public class ArrayListTest {
	
	public static void main(String[] args) {
		
		// 创建一个大集合的对象
		ArrayList<ArrayList<Student>> bigArray = new ArrayList<ArrayList<Student>>();
		//ArrayList<> bigArray = new ArrayList<>();与上面的区别
		//创建第一个子集合对象ArrayList<Student>
		ArrayList<Student> firstArray = new ArrayList<Student>() ;
		
		//创建学生对象
		Student s1 = new Student("唐", 30) ;
		Student s2 = new Student("猪", 22) ;
		Student s3 = new Student("孙", 26) ;
		
		//给第一个集合中添加元素
		firstArray.add(s1) ;
		firstArray.add(s2) ;
		firstArray.add(s3) ;
		
		//将第一个子集合添加到大集合中
		bigArray.add(firstArray) ;
		
		//创建第二个子集合对象
		ArrayList<Student> secondArray = new ArrayList<Student>() ;
		
		//创建学生对象
		Student s4 = new Student("高圆圆", 30) ;
		Student s5 = new Student("邓超", 22) ;
		Student s6 = new Student("朱亚文", 26) ;
		
		//给第二个子集合中添加元素
		secondArray.add(s4) ;
		secondArray.add(s5) ;
		secondArray.add(s6) ;
		
		//将第二个子集合添加到大集合中
		bigArray.add(secondArray) ;
		
		//创建第二个子集合对象
		ArrayList<Student> thirdArray = new ArrayList<Student>() ;
		
		//创建学生对象
		Student s7 = new Student("高圆圆", 30) ;
		Student s8 = new Student("邓超", 22) ;
		Student s9 = new Student("朱亚文", 26) ;
		
		//给第二个子集合中添加元素
		thirdArray.add(s7) ;
		thirdArray.add(s8) ;
		thirdArray.add(s9) ;
		
		
		//将第二个子集合添加到大集合中
		bigArray.add(thirdArray) ;
		
		
		//遍历大集合
		//增强for遍历
		//ArrrayList<ArrayList<student>>
		for(ArrayList<Student> array :bigArray){
			//子集合:ArrayList<Student>
			for(Student s : array){
				System.out.println(s.getName()+"---"+s.getAge());
			}
		}
		
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package org.westos_04;

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

/**
 * 泛型的高级:通配符
 * <?> :可以是任意类型,包括Object类型以及任意的Java类
 * <? extends E>:向下限定,E类型以及E类型的子类
 * <? super E>:向上限定,E类型以及E类型的父类
 * @author Orange
 */
public class GenericDemo {
	
	public static void main(String[] args) {
		//(1)引用类型与创建对象的类型必须一致，否则编译器报错
		ArrayList<Object> c1 = new ArrayList<Object>() ;
		c1.add("hello");
		//(2)由于jdk7的泛型推断---创建对象的参数类型可以不写(系统知道)
		Collection<Object> c2 = new ArrayList<>() ;
		c2.add("hello");//成功
		/**
		 * 为了说明：想写一个即可以打印list1，又可以打印list2的方法--引出通配符(随后补充)
		 * (3)为了解决泛型引用和创建两端不匹配问题！---解决方案是<?>：通配符
		 * 说明：
		 * 1）<?> :可以是任意类型,包括Object类型以及任意的Java类
		 * 2）通配符只能出现在引用的定义中(声明中)，而不能出现在创建对象中
		 * 3）其实使用通配符后，引用类型与创建对象的类型还是一致(只是系统不知道)
		 * 
		 */
		ArrayList<?> c3 =c1;
		//与上面等价===Collection<?> c1=new ArrayList<Object>() 
		//c3.add("1");----报错原因：使用了与泛型有关的方法---原因：?不知道是啥？
        System.out.println(c3.get(0));//虽然返回值类型是?,但?类型(任意类型)也是Object类的子类

		//(4)那么分析这种通配符方式和泛型推断的区别？
		/**
		 * (1)通配符方式：
		 * 参数中的通配符可以被赋任何值(类型)，但同时你也不知道通配符被赋了什么值(类型);
		 * 当你不知道“?”是什么时，就不能使用任何与泛型相关的方法;
		 * 也就是说add()方法的参数类型(E=？)不知道是啥？不能再使用它的与泛型相关的方法了
		 * 注意：可以使用get()方法---与泛型无关，接受类型为Object(非泛型E),得益于Object类是所有类的父类
		 * (2)泛型推断方式：
		 * 可以使用与泛型有关的方法
		 * ********************************************
		 * 例如：
		 * c2.add("hello");是正确的
		 * 而c3.add(“k”)是错误的，因为Collection类的add()方法的参数是T类型，
		 * 由于<?>使你不知道T是什么类型， 你怎么去添加String的东西给add呢？
		 */
		
		//(5)<? extends E>:向下限定,E类型以及E类型的子类
		ArrayList<? extends Object> c5 = c1 ;
		//c1对象的的引用参数类型是：Object
		//c5.add("hello");---不能使用与泛型相关的方法(主要是方法的参数类型是泛型的情况)
		System.out.println(c5.get(0));
		//补充
		List<? extends Number> list=new ArrayList<Double>();
		
		//(6)<? super E>:向上限定,E类型以及E类型的父类
		ArrayList<? super Animal> c6 = c1;
		c6.add(new Cat());
		//底层：? e=new Cat();----向上转型了---只知道?是Cat的父类，实际?是Object类
        //可以使用与泛型有关的方法
		List<? super Integer> list1=new ArrayList<Number>();
	}
}

//自定义两个类
class Animal{
	
}

class Cat extends Animal{
	
}