java学习12

包装类

基本数据类型使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据。
可以使用一个类，把基本类型的数据装起来，在类中定义一些方法，这个类叫做包装类。
我们可以使用类中的方法来操作这些基本类型的数据。

基本类型	包装类（引用类型，都位于java.lang包下）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱与拆箱（以Integer类为例）

装箱： 把基本类型的数据，包装到包装类中（基本类型的数据 -> 包装类）

1.构造方法：
	Integer(int value)
		【构造一个新分配的Integer对象，它表示指定的int值】

	Integer(String s)
		【构造一个新分配的Integer对象，它表示String参数所指示的int值】
		【传递的字符串必须是基本类型的字符串】

2.静态方法：
	static Integer valueOf(int i)
		【返回一个表示指定的int值的Integer对象】

	static Integer valueOf(String s)
		【返回保存指定的String的值的Integer对象】

拆箱： 在包装类中取出基本类型的数据（包装类 -> 基本类型的数据）

成员方法：
	int intValue()
		【以int类型返回该Integer的值】

public class Demo01Integer {
	
	public static void main(String[] args) {
		
		//装箱
		//构造方法
		Integer in1 = new Integer(1);
		System.out.println(in1);//1
		
		Integer in2 = new Integer("1");
		System.out.println(in2);//1
		
		//静态方法
		Integer ii1 = Integer.valueOf(1);
		System.out.println(ii1);//1
		
		Integer ii2 = Integer.valueOf("1");
		System.out.println(ii2);//1
		
		//拆箱
		int i = in1.intValue();
		System.out.println(i);//1
		
	}

}

自动装箱与自动拆箱

基本类型的数据和包装类之间可以自动的相互转换。（JDK1.5+）

public class Demo02Integer {

	public static void main(String[] args) {
		
		/*
		 * 自动装箱：直接把int类型的数据赋值包装类
		 * Integer in = 1;相当于Integer in = new Integer(1);
		 */
		Integer in = 1;
		
		/*
		 * 自动拆箱：in是包装类，无法直接参与运算，可以自动转换为基本类型数据，再进行计算
		 * in + 2相当于in.intValue() + 2
		 * in = in.intValue + 2又是一个自动装箱
		 */
		in = in + 2;
	}
	
}

基本类型与字符串之间的转换

基本类型 -> 字符串（String）

1.基本类型的值+""(最简单，常用)

2.包装类的静态方法toString(参数)【不是Object类的toString方法，是方法重载】
	
	static String toString(int i)
	【返回一个表示指定整数的String对象】

3.String类的静态方法valueOf(参数)
	
	static String valueOf(int i)
	【返回int参数的字符串表示形式】

字符串（String）-> 基本类型

使用包装类的静态方法parseXxx("字符串")
	Integer类：static int parseInt(String s)

public class Demo03 {
	
	public static void main(String[] args) {
		
		//基本类型->字符串
		int i1 = 100;
		String s1 = i1 + "";
		System.out.println(s1+"200");//100200
		
		String s2 = Integer.toString(100);
		System.out.println(s2+"200");//100200
		
		String s3 = String.valueOf(100);
		System.out.println(s3+"200");//100200
		
		//字符串 -> 基本类型
		int i2 = Integer.parseInt(s1);
		System.out.println(i2+200);//300
	}

}

Collection集合

集合： 集合是Java中提供的一种容器，可以用来存储多个数据

数组和集合的区别：
1.数组的长度是固定的，集合的长度是可变的。
2.数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象，而且对象的的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

Collection常用方法

java.util.Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）通用的一些方法，这些方法可用于操作所有的单列集合。

1.public boolean add(E e)
	【把给定的对象添加到当前集合中】

2.public void clear()
	【清空集合中所有的元素】

3.public boolean remove(E e)
	【把给定的对象在当前集合中删除】

4.public boolean contains(E e)
	【判断当前集合中是否包含给定的对象】

5.public boolean isEmpty()
	【判断当前集合是否为空】

6.public int size()
	【返回集合中元素的个数】

7.public Object[] toArray()
	【把集合中的元素存储到数组中】

Iterator迭代器

迭代： Collection集合元素的通用获取方式，在取元素之前要先判断集合中有没有元素。如果有，就把这个元素取出来，继续判断，如果还有就继续再取出来。一直把集合中的所有元素全部取出。这种取出方式，专业术语称为迭代。

java.util.Iterator接口：迭代器（对集合进行遍历）

Iterator接口的常用方法

1.public E next()
	【返回迭代的下一个元素】
	【取出下一个元素，将指针向后移动一位】
	【没有元素，若取出元素或抛出NoSearchElementException异常】

2.public boolean hasNext()
	【如果仍有元素可以迭代，返回true】

Iterator是一个接口，我们无法直接使用，需要使用Iterator接口实现类对象，获取实现类的方式比较特殊。

Collection接口中有一个方法iterator()，这个方法返回的就是迭代器的实现类对象。

Iterator<E> iterator()
【返回在此Collection的元素上进行迭代的迭代器】
【迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型】

迭代器的使用步骤：

1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
2.使用Iterator接口中的hasNext()方法判断还有没有下一个元素
3.使用Iterator接口中的next()方法取出集合中的下一个元素

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

public class Demo04Iterator {
	
	public static void main(String[] args) {
		
		//创建一个集合对象（多态）
		Collection<String> coll = new ArrayList<String>();
		//向集合中添加元素
		coll.add("1");
		coll.add("2");
		coll.add("3");
		
		//使用集合中的iterator方法获取迭代器的实现类对象，使用Iterator接口接收（多态）
		Iterator it = coll.iterator();
		
		//使用迭代器取出元素是一个重复的过程，优化
		while(it.hasNext()) {
			Object s = it.next();
			System.out.println(s);
		}
//		
//		//使用Iterator接口中的hasNext()方法判断有没有下一个元素
//		boolean a = it.hasNext();
//		System.out.println(a);
//		//使用Iterator接口中的next()方法取出下一个元素
//		Object s = it.next();
//		System.out.println(s);
//		
//		boolean a1 = it.hasNext();
//		System.out.println(a1);
//		Object s1 = it.next();
//		System.out.println(s1);
		
	}

}

增强for循环（JDK1.5+）

增强for循环，底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写。

Collection<E> extends Iterable<E>
【所有单列集合都可以使用增强for】

public interface Iterable<T>
【实现这个接口允许对象成为“foreach”语句的目标】

增强for循环：用来遍历集合和数组。

for(集合/数组的数据类型 变量名:集合名/数组名){
	System.out.println(变量名);
} 

import java.util.ArrayList;

public class Demo05For {
	
	public static void main(String[] args) {
		
		//使用增强for遍历数组
		int[] array = {1,2,3,4,5};
		for(int i : array) {
			System.out.print(i+"*");//1*2*3*4*5*
		}
		
		System.out.println();
		
		//使用增强for遍历集合
		ArrayList<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		for(String s : list) {
			System.out.print(s+"*");//aaa*bbb*ccc*
		}
		
	}

}

泛型

泛型：一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。

泛型也可以看作是一个变量用来接收数据。

E e: Element(元素)
T t: Type(类型)

创建集合对象，不使用泛型：

1.好处
	集合不使用泛型，默认就是Object类型，可以存储任意类型的数据。
2.弊端
	不安全会引发异常
		【ClassCastException：类型转换异常】

创建集合对象，使用泛型:

1.好处
	避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
	把运行期异常（代码运行之后会抛出的异常），提升到了编译期。
2.弊端
	泛型是什么类型就只能存储什么类型的数据。

泛型的定义和使用

定义和使用含有泛型的类：

修饰符 class 类名<代表泛型的变量>{
}

public class Demo06Generic {
	
	public static void main(String[] args) {
		
		//不写泛型，默认为Object
		GenericClass gc1 = new GenericClass();
		gc1.setName("一");
		Object g1 = gc1.getName();
		System.out.println(g1);//一
		
		//创建GenericClass对象，使用Integer类型
		GenericClass<Integer> gc2 = new GenericClass<Integer>();
		gc2.setName(1);
		Integer g2 = gc2.getName();
		System.out.println(g2);//1
		
		//创建GenericClass对象，使用String类型
		GenericClass<String> gc3 = new GenericClass<String>();
		gc3.setName("三");
		String g3 = gc3.getName();
		System.out.println(g3);//三
	}

}

public class GenericClass<E> {
	
	private E name;

	public E getName() {
		return name;
	}

	public void setName(E name) {
		this.name = name;
	}
	
	

}

定义和使用含有泛型的方法

【泛型定义在方法的修饰符和返回值类型之间】
	
	修饰符 <泛型> 返回值类型 方法名称(参数列表(使用泛型)){
		方法体
	}

含有泛型的方法在方法调用的时候确定泛型的数据类型。
传递什么类型的参数，泛型就是什么类型。

public class Demo07GenericMethod {
	
	public static void main(String[] args) {
		//创建GenricMethod对象
		GenericMethod gm = new GenericMethod();
		
		gm.method1(1);//1
		gm.method1("一");//一
		gm.method1(true);//true
		
		
		GenericMethod.method2("静态方法，直接使用类名调用");//静态方法，直接使用类名调用
		GenericMethod.method2(2);//2
		
	}

}

public class GenericMethod {
	
	//定义一个使用泛型的方法
	public <M> void method1(M m) {
		System.out.println(m);
	}
	
	//定义一个使用泛型的静态方法
	public static <M> void method2(M m){
		System.out.println(m);
	}

}

定义和使用含有泛型的接口

修饰符 interface 接口名<泛型>{}

【定义接口的实现类，实现接口时指定接口的泛型】
【接口使用什么泛型，实现类就是用什么泛型，创建对象时确定泛型的类型】

public class Demo08GenericInterface {
	
	public static void main(String[] args) {
		//创建GenericInterfaceImpl1对象
		GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
		gi1.method("字符串");//字符串
		
		//创建一个GenericInterfaceImpl2对象
		GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<Integer>();
		gi2.method(2);//2
	}

}

public interface GenericInterface<I> {
	
	public abstract void method(I i);

}

public class GenericInterfaceImpl1 implements GenericInterface<String>{

	@Override
	public void method(String i) {
		// TODO Auto-generated method stub
		System.out.println(i);
	}

}

public class GenericInterfaceImpl2<I> implements GenericInterface<I>{

	@Override
	public void method(I i) {
		// TODO Auto-generated method stub
		System.out.println(i);
	}

}

泛型通配符

?
【代表任意的数据类型】
【不能创建对象使用，只能作为方法的参数使用】

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

public class Demo09Generic {
	
	public static void main(String[] args) {
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		list1.add(1);
		
		ArrayList<String> list2 = new ArrayList<String>();
		list2.add("一");
		
		printList(list1);//1
		printList(list2);//一
		
//		ArrayList<?> list3 = new ArrayList<?>();	错误写法
	}
	
	public static void printList(ArrayList<?> list) {
		Iterator it = list.iterator();//迭代器
		while(it.hasNext()) {
			Object i = it.next();
			System.out.println(i);
		}
	}

}

1.泛型的上限限定

	? extends E
	【代表使用的泛型只能是E类型的子类或E本身】
	
2.泛型的下限限定
	
	? super E
	【代表使用的泛型只能是E类型的父类或E本身】