Java 进阶知识（七）

package list;

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

/**
 * java.util.List接口
 * List继承自Collection
 * List的特点:可重复，并且有序，提供了一组可以
 * 通过下标操作元素的方法。
 * 
 * 常用实现类:
 * java.util.ArrayList:内部由数组实现，查询
 * 性能更好。
 * java.util.LinkedList:内部由链表实现，增删
 * 元素性能更好，尤其首尾增删元素。
 * 在对性能没有特别苛刻要求下，通常使用的是
 * ArrayList即可。
 * 
 * @author ta
 *
 */
public class GetSetDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		list.add("five");
		System.out.println(list);
		/*
		 * E get(int index)
		 * 获取给定下标对应的元素
		 */
		String str = list.get(1);
		System.out.println(str);
		//List可以用普通的for循环遍历
		for(int i=0;i<list.size();i++) {
			str = list.get(i);
			System.out.println(str);
		}
		
		/*
		 * E set(int index, E e)
		 * 将给定元素设置到指定位置，返回值为
		 * 原位置对应元素。所以set方法的意义是
		 * 替换元素操作
		 */
		//[one,2,three,four,five]
		String old = list.set(1, "2");
		System.out.println(list);
		System.out.println(old);
	}
}

package list;

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

/**
 * 获取子集操作
 * List subLis(int start,int end)
 * 获取当前集合指定下标对应范围内的元素
 * @author ta
 *
 */
public class SubListDemo {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++) {
			list.add(i);
		}
		System.out.println(list);
		
		List<Integer> subList = list.subList(3, 8);
		System.out.println(subList);
		/*
		 * 将子集每个元素扩大10倍
		 */
		for(int i=0;i<subList.size();i++) {
			subList.set(i,subList.get(i)*10);
		}
		System.out.println(subList);
		/*
		 * 操作子集就是对原集合对应元素的操作
		 */
		System.out.println(list);
		
		/*
		 * 将list集合中2-8删除
		 */
		list.subList(2, 9).clear();
		System.out.println(list);
	}
}

package list;

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

/**
 * List提供了一对重载的add,remove方法
 * @author ta
 *
 */
public class AddRemoveDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		list.add("five");
		System.out.println(list);
		/*
		 * void add(int index,E e)
		 * 将给定元素插入到指定位置
		 * 
		 * [one,2,two,three,four,five]
		 */
		list.add(1, "2");
		System.out.println(list);
		/*
		 * E remove(int index)
		 * 删除并返回给定位置对应的元素
		 * [one,2,three,four,five]
		 */
		String old = list.remove(2);
		System.out.println(list);
		System.out.println(old);
	}
}

package list;

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

/**
 * 集合转换为数组
 * 集合提供了一个方法:toArray，可以将当前
 * 集合转换为一个数组
 * @author ta
 *
 */
public class CollectionToArrayDemo {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		c.add("one");
		c.add("two");
		c.add("three");
		c.add("four");
		System.out.println(c);
		
//		Object[] array = c.toArray();
		String[] array = c.toArray(new String[c.size()]);
		System.out.println(array.length);
		System.out.println(Arrays.toString(array));
	}
}

package list;

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

/**
 * 数组转换为List集合。
 * 通过数组的工具类:Arrays的静态方法asList
 * 可以将一个数组转换为一个List
 * 
 * @author ta
 *
 */
public class ArrayToListDemo {
	public static void main(String[] args) {
		String[] array = {"one","two","three","four"};
		
		List<String> list = Arrays.asList(array);
		System.out.println(list);
		/*
		 * 数组转换的集合对其元素操作就是对
		 * 原数组对应元素的操作
		 */
		list.set(1, "2");
		System.out.println(list);
		System.out.println("array:"+Arrays.toString(array));
		/*
		 * 由于数组是定长的，所以不支持集合
		 * 的增删操作，下面的操作会抛出异常
		 */
//		list.add("five");
	
		/*
		 * 所有的集合都提供了一个参数为Collection
		 * 的构造方法，作用是在创建当前集合的同时
		 * 包含给定集合中的所有元素
		 */
		List<String> list2 
			= new ArrayList<String>(list);

		list2.add("five");
		System.out.println(list2);
	}
}

package list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 集合工具类:java.util.Collections
 * 其提供了一个静态方法：sort，可以对List集合
 * 进行自然排序(从小到大)
 * @author ta
 *
 */
public class SortListDemo {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		Random random = new Random();
		for(int i=0;i<10;i++) {
			list.add(random.nextInt(100));
		}
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
	}
}

package list;
/**
 * 使用当前类实例作为集合元素，测试集合相关
 * 操作。
 * @author ta
 *
 */
public class Point implements Comparable<Point>{
	private int x;
	private int y;
	public Point(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public String toString() {
		return "("+x+","+y+")";
	}
	public boolean equals(Object obj) {
		if(obj == null) {
			return false;
		}
		if(obj == this) {
			return true;
		}
		if(obj instanceof Point) {
			Point p = (Point)obj;
			return this.x==p.x&&this.y==p.y;
		}
		return false;
	}
	/**
	 * 当一个类实现了Comparable接口后必须重写
	 * 方法：compareTo
	 * 该方法的作用是比较当前对象this与方法的
	 * 参数对象o之间的大小。
	 * 
	 * 返回值不关心具体取值，只关心取值范围
	 * 当返回值>0:当前对象大于参数对象(this>o)
	 * 当返回值<0:当前对象小于参数对象
	 * 当返回值=0:两个对象相等 
	 */
	public int compareTo(Point o) {
		int len = this.x*this.x+this.y*this.y;
		int olen = o.x*o.x+o.y*o.y;
		return len-olen;
	}
}

package list;

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

/**
 * 排序自定义类型元素
 * @author ta
 *
 */
public class SortListDemo2 {
	public static void main(String[] args) {
		List<Point> list = new ArrayList<Point>();
		list.add(new Point(3,4));
		list.add(new Point(4,9));
		list.add(new Point(2,7));
		list.add(new Point(8,1));
		list.add(new Point(6,0));
		list.add(new Point(4,4));
		System.out.println(list);
		/*
		 * Collections的sort方法排序的集合要求
		 * 元素必须实现Comparable接口。
		 */
		Collections.sort(list);
		System.out.println(list);
	}
}

package list;

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

/**
 * 排序字符串
 * @author ta
 *
 */
public class SortListDemo3 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("小泽老师");
		list.add("传奇");
		list.add("苍老师");	
		System.out.println(list);
		/*
		 * String已经实现了Comparable接口
		 * 比较规则为按照每个字符的unicode编码
		 * 比较。
		 * 对于排序中文时，没有什么意义。
		 * 
		 * 对此，该sort方法的使用相对局限。
		 * 所以当:
		 * 排序自定义类型元素或java提供的已经实现
		 * 过Comparable接口的元素，但是比较方法不
		 * 满足我们排序需求时，都不应当使用下面的
		 * sort方法
		 * 
		 */
		Collections.sort(list);
		System.out.println(list);
	}
}

package list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Collections提供了一个重载的sort方法，该
 * 方法除了要求传入要排序的集合外，还要求再
 * 传入一个比较器(Comparator),该比较器可以
 * 定义一种比较规则，该sort方法会用这个比较
 * 规则对集合元素比较后进行排序。
 * 
 * @author ta
 *
 */
public class SortListDemo4 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("传奇");
		list.add("小泽老师");
		list.add("苍老师");
		System.out.println(list);
		/*
		 * 这种排序方法不要求集合元素必须实现Comparable
		 * 接口，对此在排序自定义元素时不对我们的代码
		 * 产生额外侵入，由于可以自定比较规则，对于像
		 * String这样已经实现类比较方法的可以做到按照
		 * 我们的比较规则排序。
		 * 开发中推荐中这种方式排序.
		 */
		Collections.sort(
		 list,new Comparator<String>() {
			public int compare(String o1, String o2){
				//按照字符多少比大小
				return o1.length()-o2.length();
			}
		});
		System.out.println(list);
	}
}

package list;

import java.util.LinkedList;
import java.util.Queue;

/**
 * java.util.Queue
 * Queue接口继承自Collection。
 * 队列也可以保存一组元素，但是存取元素必须
 * 遵循先进先出模式。
 * 常用实现类:LinkedList
 * @author ta
 *
 */
public class QueueDemo {
	public static void main(String[] args) {
		Queue<String> queue = new LinkedList<String>();
		/*
		 * offer是入队操作，向队列末尾追加
		 * 元素
		 */
		queue.offer("one");
		queue.offer("two");
		queue.offer("three");
		queue.offer("four");
		queue.offer("five");
		queue.offer("six");
		System.out.println(queue);
		/*
		 * poll方法是出队操作
		 * 获取队首元素后该元素即从队列中
		 * 被删除
		 */
		String str = queue.poll();
		System.out.println(str);
		System.out.println(queue);
		/*
		 * peek是引用队首元素，元素不做出队
		 * 操作
		 */
		str = queue.peek();
		System.out.println(str);
		System.out.println(queue);
		
		
		/*
		 * 遍历队列
		 * 使用迭代器遍历，元素不会因此被队列
		 * 删除
		 * 
		 */
		for(String s : queue) {
			System.out.println(s);
		}
		System.out.println(queue);
		
		/*
		 * 使用poll方法遍历队列
		 */
		while(queue.size()>0) {
			String s = queue.poll();
			System.out.println(s);
		}
		System.out.println(queue);
	}
}

package list;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 双端队列
 * java.util.Deque接口
 * Deque继承自Queue接口
 * 双端队列是指队列两端都可以做进出队操作。
 * 常用实现类:LinkedList
 * @author ta
 *
 */
public class DequeDemo {
	public static void main(String[] args) {
		Deque<String> deque = new LinkedList<String>();
		
		deque.offer("one");
		deque.offer("two");
		deque.offerFirst("three");
		deque.offerLast("four");
		
		System.out.println(deque);
		
		String str = deque.poll();
		System.out.println(str);
		System.out.println(deque);
		
		str = deque.pollFirst();
		System.out.println(str);
		System.out.println(deque);
		
		str = deque.pollLast();
		System.out.println(str);
		System.out.println(deque);
	}
}

package list;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 栈结构
 * 栈也可以保存一组元素，但是存取元素必须遵循
 * 先进后出原则。
 * Deque双端队列可以实现栈，并且为栈专门提供
 * 了两个方法:push,pop
 * 通常我们使用栈是为了实现"后退"这样等功能
 * @author ta
 *
 */
public class StackDemo {
	public static void main(String[] args) {
		Deque<String> stack = new LinkedList<String>();		
		stack.push("one");
		stack.push("two");
		stack.push("three");
		stack.push("four");
		stack.push("five");
		System.out.println(stack);
		
		String str = stack.pop();
		System.out.println(str);
		System.out.println(stack);
	}
}

package list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 集合有线程安全的实现。我们可以借助Collections
 * 将现有的集合转换为一个线程安全的。
 * @author ta
 *
 */
public class SyncDemo {
	public static void main(String[] args) {
		/*
		 * List中常用的实现类:
		 * ArrayList,LinkedList它们都不是
		 * 线程安全的。
		 */
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		System.out.println(list);
		/*
		 * 将给定的集合转换为一个线程安全的
		 */
		list = Collections.synchronizedList(list);
		System.out.println(list);
		/*
		 * HashSet同样也不是线程安全的
		 */
		Set<String> set = new HashSet<String>(list);
		set = Collections.synchronizedSet(set);
		System.out.println(set);
		
		/*
		 * 文档上有说明一个事情:
		 * 即使是一个线程安全的集合，它也不同
		 * 迭代器遍历做互斥，所以这个操作要自行
		 * 维护。
		 */
		
		
		/*
		 * 队列也有并发安全的实现
		 * 阻塞队列
		 * BlockingQueue,BlockingDeque
		 * 阻塞队列内部使用双缓冲实现，在保证
		 * 并发安全的前提下解决了存取互斥问题
		 * 所以并发效率更好
		 */
		BlockingQueue<String> queue
			= new LinkedBlockingQueue<String>();
		
		queue.offer("one");
		try {
			queue.offer("two", 500, TimeUnit.MILLISECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}