10.12-包装类、大整形与集合框架

包装类

八个基本类型不能参与面向对象的开发，因为其不是Object类的子类，所以不能以多态的角度去看待；为此，Java为八个基本类型提供了对应的包装类

基本类型

• byte ->Byte

• short -> Short

• int -> Integer

• long ->Long

• float -> Float

• double -> Double

• boolean -> Boolean

• char -> Character

例子

package day10_12;

public class IntegerDemo {
	public static void main(String[] args) {
//		int a = new int(1); //错误语法
		/*
		 * 为了让基本类型也能够参与面向对象的开发(用于属性和方法)
		 * 包装类允许通过构造器将给定的基本类型数据转换为对应的包装类实例
		 */
		//此处的'1'是int类型的字面量，通过构造器将其包装为Integer类型
		Integer i = new Integer(1);
		Long l = new Long(1L);
		Double d = new Double(1.1);
		Character c = new Character('a');
		Integer i1 = new Integer(1);
		System.out.println(i==i1);//false
		//包装类重写了equals()方法，可以直接比较内容
		System.out.println(i.equals(i1));//true
		/*
		 * 创建包装类实例时，推荐的做法是使用包装类提供的静态方法
		 * valueOf()
		 * 该方法的好处在于它会将字面量值进行缓存并重用；其缓存一字节的值
		 */
		Integer n1 = Integer.valueOf(1);
		Integer n2 = Integer.valueOf(1);
		System.out.println(n1==n2);//true
		Double d1 = Double.valueOf(1.0);
		Double d2 = Double.valueOf(1.0);
		//Double类型没有任何的缓存
		System.out.println(d1==d2);//false
		Long l1 = Long.valueOf(1L);
		Long l2 = Long.valueOf(1L);
		System.out.println(l1==l2);
		/*
		 * 从包装类转换为基本类型
		 * xxxValue()
		 */
		int in = i.intValue();
		double dou = d.doubleValue();
		long lon = l.longValue();
		System.out.println(in+","+dou+","+lon);
	}
}

自动拆装箱特性

自动装箱

将基本类型的数据自动转换为对应的包装类实例

自动拆箱

将包装类实例的数据自动转换为基本类型的数据

例子

package day10_12;

public class IntegerDemo02 {
	public static void main(String[] args) {
		Object[] arr = new Object[10];
//		arr[0] = Integer.valueOf(1);//向上转型
		/*
		 * 自动装箱:
		 * 将基本类型的数据自动转换为对应的包装类实例
		 */
		arr[0] = 1;//自动装箱后，自动向上转型为object类型
		/*
		 * 上面的语法在JDK1.5之前是非法的；
		 * 但在JDK1.5之后支持了自动拆装箱特性，此写法是合法的。
		 */
		Integer i = (Integer) arr[0]; //向下转型
//		int in = i.intValue();
		int in = i;//自动拆箱
		/*
		 * 自动拆箱
		 * 包装类实例自动的调用xxxValue()方法转换为对应基本类型数据的过程称之为自动拆箱
		 */
		System.out.println(in);//1
		
		
	}
}

支持的常量与方法

• MAX_VALUE 获取相对应基本类型的最大值

• MIN_VALUE 获取相对应基本类型的最小值

• parseXXX(String str) 可以将字符串转换为对应的基本类型数据

例子

package day10_12;

public class IntegerDemo03 {
	public static void main(String[] args) {
		int max = Integer.MAX_VALUE;
		int min = Integer.MIN_VALUE;
		System.out.println(max+","+min);//2147483647,-2147483648
		/*
		 * 将字符串转换为基本类型数据时，
		 * 字符串的格式必须要完全匹配基本类型的值
		 * 否则会抛出数据格式错误异常(NumberFormatException)
		 */
		String intstr = "123";
		int i = Integer.parseInt(intstr);
		System.out.println(i);//123
		String doublestr = "12.3";
		double d = Double.parseDouble(doublestr);
		System.out.println(12.3);
		/*
		 * Integer还提供了三个方法,可以将一个整数
		 * 转换为对应的二、八、十六进制
		 */
		String bstr = Integer.toBinaryString(5000);
		System.out.println(bstr);//二进制转换
		String ostr = Integer.toOctalString(5000);
		System.out.println(ostr);//八进制转换
		String hstr = Integer.toHexString(5000);
		System.out.println(hstr);//十六进制转换
	}
}

java.math.BigInteger(大整形)

可以提供比Long更大的整数存放

例子

package day10_12;

import java.math.BigInteger;

public class BigIntegerDemo01 {
	/*
	 * BigInerger也支持valueOf()方法
	 * 加:add()
	 * 减:subtract()
	 * 乘:multiply()
	 * 除:divide()
	 */
	public static void main(String[] args) {
		//计算10的阶乘
//		int sum = 1;
//		for(int i=2;i<=10;i++) {
//			sum = sum*i;
//		}
//		System.out.println(sum);
		//计算200的阶乘 1*2*3*4...*200=？
		BigInteger sum = BigInteger.valueOf(1);
		for(int i =2;i<=200;i++) {
			sum = sum.multiply(BigInteger.valueOf(i));
		}
		System.out.println(sum);
	}
}

java.math.BigDecimal

可以做很精确的小数运算，并且可以保存精确的小数

package day10_12;

import java.math.BigDecimal;

public class BigDecimalDemo {
	/**
	 * BigDecimal也支持valueOf()方法
	 * 加:add()
	 * 减:subtract()
	 * 乘:multiply()
	 * 除:divide()
	 */
	public static void main(String[] args) {
		BigDecimal d1 = BigDecimal.valueOf(3.0);
		BigDecimal d2 = BigDecimal.valueOf(2.6);
		BigDecimal d3 = d1.subtract(d2);
		System.out.println(d3);//0.4
		BigDecimal d4 = d1.divide(d2, 20, BigDecimal.ROUND_HALF_UP);//四舍五入
		System.out.println(d4);
	}
}

Java中的集合框架

Collection接口

该接口是所有接口的超类（父接口）

其派生了List/Set集合

List集合:可重复集、有序集

Set集合:不可重复集、无序集

不可重复:指Set集合中不可以出现两个equals()比较为true的元素

注意:数组不属于集合的范畴

常用方法

int size() 返回集合中的元素数量

boolean isEmpty() 判断集合中是否包含元素，不包含则返回true

boolean contains(Object o) 判断当前集合中是否包含给定的元素

void clear() 清空集合

boolean add(元素类型 e) 向当前集合添加元素，添加成功则返回true

boolean remove(Object o) 从当前集合中删除给定的元素，删除成功则返回true

boolean addAll(Collection o) 将给定集合中的所有元素添加到当前集合中

boolean removeALL(Collection o) 删除当前集合中与给定集合相同的元素

boolean retainALL(Collection o) 只保留当前集合中与给定集合相同的元素

Iterator Iterator() 返回用于遍历集合的迭代器

例子

package day04;

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

public class CollectionDemo {
	public static void main(String[] args) {
		//ArrayList内部就是由一个数组对象来实现的
		Collection c1 = new ArrayList();
		Collection c2 = new ArrayList();
		Collection c3 = new ArrayList();
		c1.add("one");
		c1.add("two");
		c1.add("three");
//		c1.add(1);
		c2.add("four");
		c2.add("five");
		c3.add("one");
		c3.add("two");
		System.out.println(c1);
		System.out.println(c1.size());//3
		System.out.println(c1.isEmpty());//false
		System.out.println(c1.contains("one"));//true
//		c1.clear();
//		c1.remove("one");
		c1.addAll(c2);
		c1.removeAll(c3);
		c1.retainAll(c2);
		System.out.println(c1);
	}
}

List集合

常见实现类

ArrayList 内部使用数组来实现

LinkedList 内部使用链表来实现

Vector 不常用

例子-ArrayList

package day04;

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

public class ListDemo01 {
	/**
	 * List接口是Collection派生出的一个子接口
	 * 用于标识该种集合为可重复集,通常情况下
	 * List集合是有序集,允许我们通过下标的形式
	 * 访问集合中的元素
	 */
	public static void main(String[] args) {
		List list = new ArrayList();
		//对于List集合而言,add()方法就是向集合的末尾追加元素
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("one");
		System.out.println(list);
		/*
		 * List集合还提供了一个重载的add()方法
		 * void add(int index,E e)
		 * 将给定的元素插入到给定的位置
		 */
		list.add(2,"二");
		System.out.println(list);
		/*
		 * List集合提供了一个重载的remove()方法
		 * Object remove(int index)
		 * 删除给定位置的元素,返回的是被删除的元素
		 */
		Object r = list.remove(1);
		System.out.println(r);
		System.out.println(list);
		/*
		 * List集合特有的方法
		 * int indexOf(Object o)
		 * 查看给定元素在集合中的下标
		 * 若是集合中不包含该元素,则返回-1
		 */
		int index = list.indexOf("four");
		System.out.println(index);
		index = list.lastIndexOf("one");
		System.out.println(index);
	}
}

例子-get/set

package day04;

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

public class ListDemo02 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("one");
		list.add("two");
		list.add("three");
		/*
		 * Object get(int index)
		 * 根据给定的下标获取对应的元素
		 */
		Object obj = list.get(1);
		System.out.println(obj);
		/*
		 * Object set(int index,Object o)
		 * 将集合中给定位置的元素替换为给定的元素
		 * 返回的是被替换的元素
		 */
		Object r = list.set(2,"三");
		System.out.println(r);
		System.out.println(list);
		//遍历list集合
		for(int i = 0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		/*
		 * Object[] toArray()
		 * 该方法用于将集合转换为数组
		 */
		Object[] array = list.toArray();
		//遍历array数组
		for(int i = 0;i<array.length;i++) {
			System.out.println(array[i]);
		}
	}
}

例子-泛型支持

package day04;

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

public class ListDemo03 {
	/**
	 * 集合支持泛型
	 * 泛型指定的是集合中的元素类型
	 */
	public static void main(String[] args) {
		List<String> list = 
				new ArrayList<String>();
		list.add(" one ");
		list.add(" two ");
		list.add(" three ");
		//遍历list集合
		for(int i = 0;i<list.size();i++) {
			System.out.println(list.get(i).trim());
		}
		List list1 = 
				new ArrayList();
		list1.add(" one ");
		list1.add(" two ");
		list1.add(" three ");
		//遍历list1集合
		for(int i = 0;i<list1.size();i++) {
//			System.out.println(((String)list1.get(i)).trim());
			System.out.println(list1.get(i).toString().trim());		
		}
		List l = list;
		l.add(4);
		//遍历list集合
		for(int i = 0;i<list.size();i++) {
			System.out.println(list.get(i).trim());
		}
	}
}

泛型

泛指的某一种类型

JDK1.5以后的新特性

例子

package day04;

/*
 * 若想在一个类中使用泛型,必须要在类名的
 * 后面使用<>声明泛型的使用
 * 泛型的名称是自定义的,一般就使用大写字母即可
 */
public class Point<X,Y> {//点类
	private X x;
	private Y y;
	public Point() {
		
	}
	public Point(X x,Y y) {
		this.x = x;
		this.y = y;
	}
	public X getX() {
		return x;
	}
	public void setX(X x) {
		this.x = x;
	}
	public Y getY() {
		return y;
	}
	public void setY(Y y) {
		this.y = y;
	}
	@Override
	public String toString() {
		return "(" + x + "," + y + ")";
	}
}

Iterator Iterator()

返回用于遍历集合的迭代器

例子-迭代器遍历

package day04;

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

public class IteratorDemo01 {
	/**
	 * 遍历集合元素有一种通用方式:迭代器模式
	 */
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("one");
		c.add("#");
		c.add("two");
		c.add("#");
		c.add("three");
		c.add("#");
		c.add(null);
		System.out.println(c);
		/*
		 * Iterator是一个接口
		 * 不同的集合返回的迭代器实现不尽相同
		 */
		Iterator it = c.iterator();
		System.out.println(it);
		/*
		 * 注意:
		 * 使用迭代器遍历集合的顺序必须遵循:
		 * 问取删(删除并不是必须的)
		 * 问:boolean hasNext()
		 * 该方法的作用是查看当前集合中是否还有元素可以遍历
		 * 取:Object next()
		 * 从集合中取出一个元素
		 * 删:void remove()
		 * 删除通过next()方法遍历出来的元素
		 */
		while(it.hasNext()) {
			Object obj = it.next();
			if("#".equals(obj)) {
				it.remove();
				/*
				 * 迭代器遍历集合有一个要求:
				 * 在迭代的过程中不允许通过集合中的
				 * 方法增删元素
				 */
//				c.remove("#");
			}
//			it.remove();
			System.out.println(obj);
		}
		System.out.println(c);
	}
}

例子-泛型支持

package day04;

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

public class IteratorDemo02 {
	/**
	 * 迭代器通常支持泛型
	 * 并且迭代的泛型类型与其遍历集合的泛型类型要一致
	 */
	public static void main(String[] args) {
		List<String> list = 
				new ArrayList<String>();
		list.add(" one ");
		list.add(" two ");
		list.add(" three ");
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next().trim());
		}
	}
}