黑马程序员_API_包装类&set&list集合

----------- android培训、java培训、期待与您交流！----------

一、基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character 
  
该对象常见场景：
在基本数据值和字符串之间做转换。
  
基本类型值--->字符串。  34+"" = "34"; String.valueOf(基本数据类型值);
Integer : static 字符串 toString(基本类型值);
  
字符串--->基本类型值。

Integer : static XXX parseXXX(字符串);

Integer覆盖了Object的equals方法。建立自己的判断相同的依据，只要对象中的数值相同即可。

进制转换。
十进制-->其他进制。
System.out.println(Integer.toBinaryString(-6));转二进制
System.out.println(Integer.toHexString(26));转16进制

其他进制-->十进制。需要说明此字符串是几进制
System.out.println(Integer.parseInt("110",2));

基本数据值--->对象。
Integer i = new Integer(23);
Integer ii = Integer.valueOf(23);

对象---->基本数据类型值。
int num = i.intValue();

二、自动装箱拆箱
Integer i = 34;//Integer i = Integer.valueOf(34);自动装箱
i = i + 2;//i+2,i先转成一个整数，i.intValue()自动拆箱。
//i = Integer.valueOf(i.intValue()+2);

Integer a = 127;
Integer b = 127;
System.out.println(a==b);//true 128false
System.out.println(a.equals(b));//true
如果存的数小于一个字节，是不会在内存中开辟新的空间的

三、常见方法
Collection
boolean b = c1.removeAll(c2);//将c1中与c2中相同的元素从c1中删除。
boolean b = c1.retainAll(c2);//将c1与c2中相同的元素保留到c1中，不同的被删除。

//List特有的取出所有元素的方式。
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

容器的出现降低了容器和元素自身特点的耦合性，如何取出不用管。
迭代器的出现将取出方式和具体的容器进行解耦。不管容器自身是什么特点，用迭代器的规则就能取出所有的元素，不论什么容器。

普通迭代器无法做到遍历时对元素进行操作，当迭代器和集合同时在操作容器中的元素，但是不允许这种修改，迭代的时候就会出现问题。
列表迭代器是List集合的特有迭代器，可以在迭代过程中实现增删改查。
ListIterator it = list.listIterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc2")){
it.add("abc9");
}
}

LinkedList

public class LinkedListTest {
			public static void main(String[] args) {
				/*
				 * 用LinkedList模拟堆栈或者队列数据结构。remove和add相同就是堆栈，不同就是队列
				 * 
				 * 堆栈：先进后出。First In Last Out  FILO.
				 * 队列：先进先出。First In First Out FIFO.
				 * 
				 */
				//创建一个自定义个堆栈容器。
				MyStack stack = new MyStack();				
				stack.myAdd("abc1");
				stack.myAdd("abc2");
				stack.myAdd("abc3");
				stack.myAdd("abc4");
				stack.myAdd("abc5");	
				while(!stack.isNull()){
					System.out.println(stack.myGet());
				}
			}
		}
		//描述一个具备先进后出的数据结构堆栈。 
		class MyStack{
			private LinkedList link;
			
			MyStack(){
				link = new LinkedList();
			}
			
			/**
			 * 提供一个存储元素的方法。
			 */
			public void myAdd(Object obj){
				link.addLast(obj);
			}
			
			/**
			 *  提供一个获取元素的方法。
			 */
			public Object myGet(){
				return link.removeLast();
			}
			
			/**
			 * 判断容器中是否有元素。
			 */
			public boolean isNull(){
				return link.isEmpty();
			}
		}

ArrayList
去除ArrayList集合中的重复元素。

public static void getSingleElmement2(List list) {
		for (int x = 0; x < list.size(); x++) {
			Object obj = list.get(x);
			for (int y = x + 1; y < list.size(); y++) {
				if (obj.equals(list.get(y))) {
					list.remove(y);
					y--;
				}
			}
		}
	}

四。体系
Collection：
|--List
|--Set

List：
1，是有序的,存入的顺序和取出的顺序一致。
2，元素是有索引的。
3，元素可以重复。

了解List接口的特有方法，注意：这些特有方法都是围绕着角标定义的。
1,add(index,element);
2,remove(index):
3,set(index,element);
4,get(index);

List接口支持，增删改查操作。

List
|--Vector:数组结构的,是同步的。被ArrayList替代，因为效率低。

|--ArrayList:数据结构是数组结构，是不同步的。查询速度很快。

|--LinkedList:数据结构是链表结构，是不同步的。增删速度很快。

划分容器依据的就是数据结构不同。
想要明确这些容器如何用必须先要明确其数据结构
数据结构是计算机存储、组织数据的方式。

可变长度数组：当超过了数组长度存储元素时，会创建一个新数组并把原数组的元素复制到新数组中。并把要加入的元素放入到新数组的位置上。

Set:元素不可以重复的。不保证顺序。
Set:
|--HashSet:哈希表结构。不同步的。查询速度快。其实hashset集合底层用的是数组
记住：存储到哈希表中的对象，必须覆盖hashCode和euqals方法。建立在哈希表判断元素唯一性的方式。
|--TreeSet:它可以对Set集合中的元素进行排序。数据结构是二叉树。不同步的。

二叉树：一个父亲有两个孩子
平衡二叉树：一个父亲有两个孩子，并且右边的孩子大于左边的孩子。
TreeSet排序有两种方式：
第一种：让元素自身具备比较性。让元素对象实现Comparable接口，覆盖compareTo方法。
但是，需求中，需要元素的非自然排序时，或者元素本身就不具备自然排序时
第二种：让容器具备比较性。其实就是定义一个比较器，就是实现Comparator接口，
覆盖compare方法。


List集合判断元素是否相同使用的equals方法。
HashSet集合判断元素相同，依据 hashCode和equals方法。，
TreeSet集合判断元素形同，依据compareTo或者compare方法的return 0;


集合名称规律：
前缀名：数据结构名。
后缀名：所属集合的名字。


ArrayList：数组结构，所属于List。想到索引，查询快。

LinkedList：链表结构，所属于List。想到增删快。

HashSet：哈希表结构，所属于Set,想到唯一性，查询速度快。

TreeSet：二叉树结构，所属于Set，想到唯一性，而且排序。
排序两种，自然排序Comaprable，compareTo比较器排序。Comparator.compare

public class Test1 {
	
	/**
	 * 写一个ArrayList类的代理，实现和ArrayList中完全相同的功能，并可以计算每个方法运行的时间
	 */
	public static void main(String[] args) throws Exception {
		final ArrayList list = new ArrayList();
		
		/*
		 * loader：类加载器，一般与被代理对象使用同一个
		 * interfaces：被代理对象所实现的接口
		 * h：怎么代理
 		 *	 Object invoke(Object proxy, Method method, Object[] args) ：调用原有类的任何方法，都会经过此方法。
		 */
		List proxy = ((List) Proxy.newProxyInstance(ArrayList.class.getClassLoader(), ArrayList.class.getInterfaces(),
				new InvocationHandler() {
					
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						long begin = System.currentTimeMillis();
						Object obj = method.invoke(list, args);
						long end = System.currentTimeMillis();
						System.out.println(method.getName() + "方法使用了" + (end - begin) + "毫秒");
						return obj;
					}

				}));

		proxy.add("aaa");
	}
}

public class Test1 {
	
	/**
	 * ArrayList list = new ArrayList();  
	 * 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
	 */
	public static void main(String[] args) throws Exception {
		List<Integer> list = new ArrayList<Integer>();
		Method method = list.getClass().getMethod("add", Object.class);
		method.invoke(list, "fuck");
		System.out.println(list);
	}

}