Java-API-3

LinkedHashMap

public static void main(String[] args) {
		HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();	
		hm.put(7, "zhouqi");
		hm.put(3, "zhangsan");
		hm.put(1, "qianyi");
		hm.put(5, "wangwu");
		
		Iterator<Map.Entry<Integer,String>> it = hm.entrySet().iterator();		
		while(it.hasNext()){
			Map.Entry<Integer,String> me = it.next();		
			Integer key = me.getKey();
			String value = me.getValue();		
			System.out.println(key+":"+value);
		}
	}

/*
 * 练习:
 * "fdgavcbsacdfs" 获取该字符串中，每一个字母出现的次数。
 * 要求打印结果是：a(2)b(1)...;
 * 思路：
 * 对于结果的分析发现，字母和次数之间存在着映射的关系。而且这种关系很多。
 * 很多就需要存储，能存储映射关系的容器有数组和Map集合。
 * 关系一方式有序编号吗？没有！
 * 那就是使用Map集合。 又发现可以保证唯一性的一方具备着顺序如 a b c ...
 * 所以可以使用TreeMap集合。
 * 
 * 这个集合最终应该存储的是字母和次数的对应关系。 
 * 
 * 1，因为操作的是字符串中的字母，所以先将字符串变成字符数组。
 * 2，遍历字符数组，用每一个字母作为键去查Map集合这个表。
 * 如果该字母键不存在，就将该字母作为键 1作为值存储到map集合中。
 * 如果该字母键存在，就将该字母键对应值取出并+1，在将该字母和+1后的值存储到map集合中，
 * 键相同值会覆盖。这样就记录住了该字母的次数.
 * 3，遍历结束，map集合就记录所有字母的出现的次数。oy.
 */
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
public class MapTest {

/**
 * @param args
 */
public static void main(String[] args) {		
	String str = "fdg+avAdc  bs5dDa9c-dfs";		
	String s = getCharCount(str);		
	System.out.println(s);	
}

public static String getCharCount(String str) {	
	//将字符串变成字符数组 
	char[] chs = str.toCharArray();	
	//定义map集合表。
	Map<Character,Integer> map = new TreeMap<Character,Integer>();		
	for (int i = 0; i < chs.length; i++) {			
		if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
				continue;		
			//将数组中的字母作为键去查map表。			
			Integer value = map.get(chs[i]);		
			int count = 1;			
			//判断值是否为null.
			if(value!=null){
				count = value+1;
			}
			map.put(chs[i], count);
		}	
		return mapToString(map);
	}

private static String mapToString(Map<Character, Integer> map) {		
	StringBuilder sb = new StringBuilder();	
	Iterator<Character> it = map.keySet().iterator();	
	while(it.hasNext()){
		Character key = it.next();
		Integer value = map.get(key);			
		sb.append(key+"("+value+")");
	}	
	return sb.toString();
	}
}

查表法

import java.util.HashMap;
import java.util.Map;

public class MapTest2 {
	public static void main(String[] args) {
		/*
		 * Map在有映射关系时，可以优先考虑。
		 * 
		 * 在查表法中的应用较为多见。
		 */		
		String week = getWeek(1);
		System.out.println(week);	
		System.out.println(getWeekByMap(week));
	}
	public static String getWeekByMap(String week){	
		Map<String,String> map = new HashMap<String,String>();	
		map.put("星期一","Mon");
		map.put("星期二","Tus");
		map.put("星期三","Wes");
		map.put("星期四","Thu");
		map.put("星期五","fri");
		map.put("星期六","Sat");
		map.put("星期日","Sun");
		map.put("星期天","Sun");
		return map.get(week);
	}
	
	public static String getWeek(int week){
		if(week<1 || week>7)
			throw new RuntimeException("没有对应的星期，请您重新输入");
		String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
		return weeks[week];
	}
}

import java.util.Comparator;
public class ComparatorByLength implements Comparator<String> {
	@Override
	public int compare(String o1, String o2) {
		int temp = o1.length() - o2.length();	
		return temp==0?o1.compareTo(o2): temp;
	}
}

数组转成集合：

public class ArraysDemo {
	public static void main(String[] args) {
		/*
		 * Arrays：集合框架的工具类。里面的方法都是静态的。
		 */
//		int[] arr = {3,1,5,6,3,6};		
//		System.out.println(Arrays.toString(arr));		
		demo_2();
	}

	public static void demo_2() {
		
		/*
		 * 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
		 * 
		 * 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。
		 * 
		 */
		int[] arr = {31,11,51,61};
		
		List<int[]> list = Arrays.asList(arr);
		
		System.out.println(list);
	}

	/**
	 * 
	 */
	public static void demo_1() {
		/*
		 * 重点：List asList(数组)将数组转成集合。
		 * 
		 * 好处：其实可以使用集合的方法操作数组中的元素。
		 * 注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的
		 * 否则会发生UnsupportedOperationException
		 */
		String[] arr = {"abc","haha","xixi"};
		
		boolean b = myContains(arr, "xixi");
		System.out.println("contains:"+b);
		
		List<String> list = Arrays.asList(arr);
		boolean b1 = list.contains("xixi");
		System.out.println("list contaisn:="+b1);
//		list.add("hiahia");	//UnsupportedOperationException		
		System.out.println(list);
	}
	
	public static boolean myContains(String[] arr,String key){
		for (int i = 0; i < arr.length; i++) {
			if(arr[i].equals(key))
				return true;
		}
		return false;
	}
	
	//toString的经典实现。
	public static String myToString(int[] a){
		int iMax = a.length - 1;
		if (iMax == -1)
	            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0;  ; i++) {//中间省略条件判断，提高了效率。
            b.append(a[i]);
	    if (i == iMax)
	    	return b.append(']').toString();
           b.append(", ");
        }
	}
}

集合转成数组：

public static void main(String[] args) {	
		/*
		 * 集合转成数组呢？
		 * 使用的就是Collection接口中的toArray方法。
		 * 集合转成数组：可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
		 */		
		List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");		
		/*
		 * toArray方法需要传入一个指定类型的数组。
		 * 长度该如何定义呢？
		 * 如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同size的数组。
		 * 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null。
		 * 
		 * 所以建议，最后长度就指定为，集合的size。
		 */
		String[] arr = list.toArray(new String[list.size()]);		
		System.out.println(Arrays.toString(arr));		
	}

foreach

public class ForEachDemo {
	public static void main(String[] args) {
		/*
		 * foreach语句：
		 * 格式：
		 * for(类型  变量   ：Collection集合|数组){	
		 * }
		 * 
		 * 传统for和高级for的区别？
		 * 传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件。
		 * 
		 * 高级for是一种简化形式。
		 * 它必须有被遍历的目标。该目标要是数组，要么是Collection单列集合。
		 * 
		 * 对数数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。
		 * 如果要对数组的角标进行操作建议使用传统for。 
		 * /
		List<String> list =new ArrayList<String>();	
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");	
		for(String s : list){	//简化书写。		
			System.out.println(s);			
		}
		int[] arr = {3,1,5,7,4};
		for(int i : arr){
			System.out.println(i);
		}
				
		//可以使用高级for遍历map集合吗？不能直接用，但是可以将map转成单列的set，就可以用了。
		Map<Integer,String> map = new HashMap<Integer,String>();
		map.put(3,"zhagsan");
		map.put(1,"wangyi");
		map.put(7,"wagnwu");
		map.put(4,"zhagsansan");
	
		for(Integer key : map.keySet()){
			String value = map.get(key);
			System.out.println(key+"::"+value);
		}
		
		for(Map.Entry<Integer,String> me : map.entrySet()){
			Integer key = me.getKey();
			String value = me.getValue();			
			System.out.println(key+":"+value);
		}
	
//		Iterator<String> it = list.iterator();	
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
	}
}

静态导入：

import static java.util.Collections.*;//静态导入，其实导入的是类中的静态成员。
//import static java.util.Collections.max;//静态导入，其实导入的是类中的静态成员。

.
.
List list = new ArrayList();//非同步的。

list = MyCollections.synList(list);//返回一个同步的list.

//给非同步的集合加锁。
class MyCollections{
	public static  List synList(List list){
		return new MyList(list);
	}

	private class MyList implements List{
		private List list;
		private static final Object lock = new Object();
		MyList(List list){	
			this.list = list;	
		}
	
		public boolean add(Object obj){
			synchronized(lock)
			{
				return list.add(obj);
			}
		}
	
		public boolean remove(Object obj){
			synchronized(lock)
			{
				return list.remove(obj);
			}
		}
	}
}

Calendar类

import java.util.Calendar;
public class CalendarDemo {
	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();	
		int year = 2012;
		showDays(year);
	}

	public static void showDays(int year) {	
		Calendar c = Calendar.getInstance();
		c.set(year, 2, 1);	
		c.add(Calendar.DAY_OF_MONTH, -1);	
		showDate(c);
	}

	public static void showDate(Calendar c) {
		int year = c.get(Calendar.YEAR);	//获取当前年份
		int month = c.get(Calendar.MONTH)+1;	//获取当前月份
		int day = c.get(Calendar.DAY_OF_MONTH);
		int week = c.get(Calendar.DAY_OF_WEEK);	
		System.out.println(year+"年"+month+"月"+day+"日"+getWeek(week));
	}

	public static String getWeek(int i) {	
		String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};		
		return weeks[i];
	}
}

Date类

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {

	/**
	 * @param args
	 * @throws ParseException 
	 */
	public static void main(String[] args) throws ParseException {
		methodDemo_3();	
	}
	
	/**
	 * 将日期格式的字符串-->日期对象。
	 * 	使用的是DateFormat类中的parse()方法。 
	 * @throws ParseException 
	 */
	public  static void methodDemo_3() throws ParseException {
		
		String str_date = "2012年4月19日";
		str_date = "2011---8---17";
					
		DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);
		
		dateFormat = new SimpleDateFormat("yyyy---MM---dd");
				
		Date date = dateFormat.parse(str_date);		
		System.out.println(date);		
	}

	/**
	 * 对日期对象进行格式化。
	 * 将日期对象-->日期格式的字符串。
	 * 	使用的是DateFormat类中的format方法。
	 */
	public static void methodDemo_2() {	
		Date date = new Date();	
		//获取日期格式对象。具体着默认的风格。 FULL LONG等可以指定风格。
		DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);
		dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
//		System.out.println(dateFormat);
		
		//如果风格是自定义的如何解决呢？
		dateFormat = new SimpleDateFormat("yyyy--MM--dd");
		
		String str_date = dateFormat.format(date);
		
		System.out.println(str_date);
	}
		
	/**
	 * 日期对象和毫秒值之间的转换。
	 * 
	 * 毫秒值-->日期对象 ： 
	 * 	1，通过Date对象的构造方法  new Date(timeMillis);
	 *  2，还可以通过setTime设置。 
	 *  因为可以通过Date对象的方法对该日期中的各个字段(年月日等)进行操作。
	 *  
	 * 日期对象-->毫秒值：
	 * 	2，getTime方法。
	 * 因为可以通过具体的数值进行运算。 

	 */
	public static void methodDemo_1() {
		long time = System.currentTimeMillis();//
//		System.out.println(time);//1335671230671
		
		Date date = new Date();//将当前日期和时间封装成Date对象。
		System.out.println(date);//Sun Apr 29 11:48:02 CST 2012
		
		Date date2 = new Date(1335664696656l);//将指定毫秒值封装成Date对象。
		System.out.println(date2);
	}
}

Math类

import java.util.Random;
public class MathDemo {
	public static void main(String[] args) {
		/*
		 * Math:提供了操作数学运算的方法。都是静态的。
		 * 
		 * 常用的方法：
		 * ceil():返回大于参数的最小整数。
		 * floor():返回小于参数的最大整数。
		 * round():返回四舍五入的整数。
		 * pow(a,b):a的b次方。
		 */
		double d1 = Math.ceil(12.56);
		double d2 = Math.floor(12.56);
		double d3 = Math.round(12.46);
		
//		sop("d1="+d1);
//		sop("d2="+d2);
//		sop("d3="+d3);
		
//		double d = Math.pow(10, 2);平方
//		sop("d="+d);
		
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
//		double d = Math.ceil(Math.random()*10);
//		double d = (int)(Math.random()*6+1);
//		double d = (int)(r.nextDouble()*6+1);
		int d = r.nextInt(6)+1;
		System.out.println(d);
		}
	}

	public static void sop(String string) {
		System.out.println(string);
	}
}

System类

import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.Set;
public class SystemDemo {
	private static final String LINE_SEPARATOR = System.getProperty("line.separator");
	public static void main(String[] args) {		
		/*
		 * System:类中的方法和属性都是静态的。
		 * 常见方法：
		 * long currentTimeMillis();获取当前时间的毫秒值。 
		 */
		
//		long l1 = 1335664696656l;//System.currentTimeMillis();
//		System.out.println(l1/1000/60/60/24);//1335664696656
//		code..
//		long l2 = System.currentTimeMillis();
//		System.out.println(l2-l1);
		
		System.out.println("hello-"+LINE_SEPARATOR+" world");
//		demo_1();
		//给系统设置一些属性信息。这些信息是全局，其他程序都可以使用。 
//		System.setProperty("myclasspath", "c:\myclass");		
	}
	
	public static void demo_1(){
		//获取系统的属性信息，并存储到了Properties集合中。 
		/*
		 * properties集合中存储都是String类型的键和值。
		 * 最好使用它自己的存储和取出的方法来完成元素的操作。
		 */
		Properties prop = System.getProperties();		
		Set<String> nameSet = prop.stringPropertyNames();		
		for(String name : nameSet){
			String value = prop.getProperty(name);			
			System.out.println(name+"::"+value);
		}		
	}	
}

Runtime类

打开记事本

import java.io.IOException;
public class RuntimeDemo {
	/**
	 * @param args
	 * @throws IOException 
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws IOException, InterruptedException {
		/*
		 * Runtime:没有构造方法摘要，说明该类不可以创建对象。
		 * 又发现还有非静态的方法。说明该类应该提供静态的返回该类对象的方法。
		 * 而且只有一个，说明Runtime类使用了单例设计模式。
		 */	
		Runtime r = Runtime.getRuntime();	
//		execute: 执行。 xxx.exe 		
		Process p = r.exec("notepad.exe");
		Thread.sleep(5000);
		p.destroy();
	}
}