Java笔记（五）

泛型：JDK1.5版本后出现的新特性。用于解决安全问题，是一个类型安全机制。

　　好处：将运行期间出现问题ClassCastException，转移到了编译时期。方便程序员解决问题，让运行时问题减少。

　　　　　避免了强制转换麻烦。

　  泛型格式：通过<>来定义要操作的引用数据类型

　　通常在集合框架中很常见，只要见到<>就要定义泛型。当使用集合时，将集合中要存储的数据类型作为参数传递到<>即可。

　　泛型类定义的泛型，在整个类中都有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

　　注：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。泛型定义在方法上时，要写在返回值类型的前面。如:public static <T> void method(T t)

Map集合：该集合存储键值对，一对一往里存。而且要保证键的唯一性。

　　添加：put(K key, V value)      putAll(Map<? extends K, ? extends V> m) 如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，put方法会返回被覆盖的值。

　　删除：clear()    remove(Object key)

　　判断：containsValue(Object value)    containKey(Object key)    isEmpty()

　　获取：get(object key)   size()    values()    entrySet()    keySet()

Map

　　|--Hashtable：底层是hash表数据结构，不可以存入null键和null值。该集合是线程同步的。jdk1.0 效率低

　　|--HashMap：底层是hash表数据结构，可以存入null键和null值。该集合是线程不同步的。jdk1.2 效率高

　　|--TreeMap：底层是二叉树数据结构，线程不同步。可以用于map集合中的键进行排序。

和Set很像。Set底层就是使用了Map集合。

Map集合的两种取出方式：

（1）Set<k> keySet：将Map中所有的键存入到Set集合。因为Set具备迭代器。所以可以用迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

（2）Set<Map.Entry<k, v>> entrySet：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是Map.Entry。Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

例：每一个学生都有对应的归属地。学生Student，地址String。学生属性：姓名，年龄。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。

（1）描述学生

（2）定义Map容器。将学生作为键，地址作为值。存入

（3）获取Map集合中的元素。

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 //import java.util.TreeMap;

 class Student implements Comparable<Student>{
     private String name;
     private int age;
     Student(String name, int age){
         this.name = name;
         this.age = age;
     }
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
     public int hashCode(){
         return name.hashCode() + age * 34;
     }
     public boolean equals(Object obj){
         if(!(obj instanceof Student)) throw new ClassCastException("类型不匹配");
         Student s = (Student)obj;
         return this.name.equals(s.name) && this.age == s.age;
     }
     public int compareTo(Student s){
         int num = new Integer(this.age).compareTo(new Integer(s.age));
         if(num == 0)
             return this.name.compareTo(s.name);
         return num;
     }
 }

 public class Demo{
     public static void main(String[] args) {
         HashMap<Student, String> hm = new HashMap<Student, String>();

         hm.put(new Student("ztq01", 20), "北京");
         hm.put(new Student("ztq02", 21), "上海");
         hm.put(new Student("ztq03", 22), "天津");
         hm.put(new Student("ztq04", 23), "重庆");

         //第一种
 //        Set<Student> key = hm.keySet();
 //        Iterator<Student> it = key.iterator();
 //        while(it.hasNext()){
 //            Student s = it.next();
 //            String value = hm.get(s);
 //            System.out.println(s.getName() + " " + s.getAge() + " ~ " + value);
 //        }

         //第二种
         Set<Map.Entry<Student, String>> entry = hm.entrySet();
         Iterator<Map.Entry<Student, String>> it = entry.iterator();
         while(it.hasNext()){
             Map.Entry<Student, String> tmp = it.next();
             Student key = tmp.getKey();
             String value = tmp.getValue();
             System.out.println(key.getName() + " " + key.getAge() + " ~ " + value);
         }
     }
 }

用TreeMap实现排序，根据姓名排序

 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;

 class Student{
     private String name;
     private int age;
     Student(String name, int age){
         this.name = name;
         this.age = age;
     }
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
     public int hashCode(){
         return name.hashCode() + age * 34;
     }
     public boolean equals(Object obj){
         if(!(obj instanceof Student)) throw new ClassCastException("类型不匹配");
         Student s = (Student)obj;
         return this.name.equals(s.name) && this.age == s.age;
     }
 }

 class stuNameComparator implements Comparator<Student>{
     public int compare(Student s1, Student s2){
         int num = s1.getName().compareTo(s2.getName());
         if(num == 0){
             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
         }
         return num;
     }
 }

 public class Demo{
     public static void main(String[] args) {
         TreeMap<Student, String> hm = new TreeMap<Student, String>(new stuNameComparator());

         hm.put(new Student("ztq01", 20), "北京");
         hm.put(new Student("ztq03", 22), "天津");
         hm.put(new Student("ztq04", 23), "重庆");
         hm.put(new Student("ztq02", 21), "上海");
         //第一种
 //        Set<Student> key = hm.keySet();
 //        Iterator<Student> it = key.iterator();
 //        while(it.hasNext()){
 //            Student s = it.next();
 //            String value = hm.get(s);
 //            System.out.println(s.getName() + " " + s.getAge() + " ~ " + value);
 //        }

         //第二种
         Set<Map.Entry<Student, String>> entry = hm.entrySet();
         Iterator<Map.Entry<Student, String>> it = entry.iterator();
         while(it.hasNext()){
             Map.Entry<Student, String> tmp = it.next();
             Student key = tmp.getKey();
             String value = tmp.getValue();
             System.out.println(key.getName() + " " + key.getAge() + " ~ " + value);
         }
     }
 }

例：“sdfgzxcvasdfxcvdf”获取该字符串中的字母出现的次数，打印结果：a(1)c(2)...

思路：（1）将字符串转换成字符数组。因为要对每个字母进行操作。

　　　（2）定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap

　　　（3）遍历字符数组，将每一个字母作为键去查Map集合。如果返回null，就将该字母和1存入到Map集合中。如果返回不为null，说明该字母在Map集合中已经存在并有对应次数。那么就获取该次数并进行自增。然后将该字母和自增后的次数存入Map集合中，覆盖原来键所对应的值。

　　　（4）将Map集合中的数据变成指定的字符串形式返回。

 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;

 public class Demo{
     public static void main(String[] args) {
         String result = charCount("sdfgzxcvasdfxcvdf");
         System.out.println(result);
     }
     public static String charCount(String s){
         char[] arr = s.toCharArray();
         TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
         for(int i = 0; i < arr.length; i++){
             int count = 0;
             Integer value = tm.get(arr[i]);
             if(value != null){
                 count = value;
             }
             count++;
             tm.put(arr[i], count);
         }
         StringBuilder sb = new StringBuilder();
         Set<Map.Entry<Character, Integer>> entry = tm.entrySet();
         Iterator<Map.Entry<Character, Integer>> it = entry.iterator();
         while(it.hasNext()){
             Map.Entry<Character, Integer> tmp = it.next();
             char key = tmp.getKey();
             Integer value = tmp.getValue();
             sb.append(key + "(" + value + ")");
         }
         return sb.toString();
     }
 }

Collections.sort();

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

 public class Demo{
     public static void main(String[] args) {
         List<String> list = new ArrayList<String>();
         list.add("abc");
         list.add("bc");
         list.add("b");
         list.add("cccc");
         System.out.println(list);
         Collections.sort(list);
         System.out.println(list);
         Collections.sort(list, new StrLenComparator());
         System.out.println(list);
     }
 }

 class StrLenComparator implements Comparator<String>{
     public int compare(String s1, String s2){
         int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
         if(num == 0){
             return s1.compareTo(s2);
         }
         return num;
     }
 }

输出结果：

[abc, bc, b, cccc]
[abc, b, bc, cccc]
[b, bc, abc, cccc]

Collections.max(list); 同上

Collections.binarySearch(list, 字符串, 比较器);   使用二分搜索法搜索指定列表，以获得指定对象。

Collections.fill(list, 字符串);   把list中的所有元素替换成传入的字符串。

Collections.replaceAll(list, old, new);  使用另一个值替换列表中出现的所有某一指定值。

Collections.reverse(list);  反转指定列表中元素的顺序。

Collections.reverseOrder(); 返回一个比较器，强行逆转实现了Comparable接口的对象collection的自然顺序

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());

Collections.swap(list, int i, int j );   在指定列表的指定位置处交换元素。

Collections.shuffle(list);   使用默认随机源对指定列表进行置换。

Arrays.asList(arr);    将数组变成list集合。

注：将数组变成集合后，不可以使用集合的增删方法。因为数组的长度是固定的。如果增删，则抛出UnsupportedOperationException异常。

　　如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

如：

int[] nums = {1, 2 ,3};
List<int[]> list = Arrays.asList(nums);
System.out.println(list);

Integer[] numss = {1, 2, 3};
List<Integer> li = Arrays.asList(numss);
System.out.println(li);

输出结果：

[[I@6af62373]
[1, 2, 3]

集合变数组：

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

 public class Demo{
     public static void main(String[] args) {
         ArrayList<String> al = new ArrayList<String>();
         al.add("abc1");
         al.add("abc2");
         al.add("abc3");
         /*
             当指定类型的数组长度小于集合的size，
             那么该方法内部会创建一个新的数组，长度为集合的size。
             当指定类型的数组长度大于集合的size，
             就不会创建新数组，而是使用传递进来的数组。
             所以创建一个刚好的数组最优。

             集合变数组是为了限定对元素的操作。
         */
         String[] arr = al.toArray(new String[al.size()]);
         System.out.println(Arrays.toString(arr));
     }
 }

高级for循环：

格式： for(数据类型 变量名：被遍历的集合(Collection)或者数组)

　　　对集合进行遍历。只能获取元素，当时不能对集合进行操作。

可变参数：数组参数的简写形式，不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。使用时，可变参数一定要定义在参数列表后边。

 public class Demo{
     public static void main(String[] args) {
         show("haha", 1, 2, 3, 4);
     }
     public static void show(String s, int ... arr){
         System.out.println(arr.length);
     }
 }

输出结果：4

System：

out：标准输出，默认是控制台。

in：标准输入，默认是键盘。

描述系统一些信息。

获取系统属性信息：Properties getProperties();

Properties prop = System.getProperties();

因为Properties是Hashtable的子类，也就是Map集合的一个子类对象，那么可以通过Map的方法取出该集合中的元素。该集合中存储的都是字符串。没有泛型定义。

System.setProperty("mykey", "myval");   自定义一些信息

String value = System.getProperty("os.name");  获取指定属性信息

Runtime：每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。

该类并没有提供构造函数，说明不可以new对象。所以该类中的方法都是静态的。该类中还有非静态方法，说明该类会提供方法获取本类对象，而且是静态的，返回值类型为本类类型。(单例模式)

static Runtime getRuntime();

Process exec(String command)  在单独的进程中执行指定的字符串命令。

Date：

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

 public class Demo{
     public static void main(String[] args) {
         Date d = new Date();
         System.out.println(d); //无格式

         //将模式封装到SimpleDateFormat对象中
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E  HH:mm:ss");

         //调用format方法，让模式格式化指定Date对象
         String time = sdf.format(d);
         System.out.println(time);
     }

 }

输出结果：

Fri Jan 20 21:39:27 GMT+08:00 2017
2017年01月20日 星期五  21:39:27

Calendar：

 import java.util.Calendar;

 public class Demo{
     public static void main(String[] args) {
         Calendar c = Calendar.getInstance();
         System.out.println(c.get(Calendar.YEAR) + "年");

         //获取任意年的二月有多少天
         c.set(2017, 2, 1); //设置某一年3月1日
         c.add(Calendar.DAY_OF_MONTH, -1);  //3月1日往前推一天，就是2月最后一天
         System.out.println(c.get(Calendar.DAY_OF_MONTH));
     }
 }

输出结果：

2017年
28

Math：

static double ceil(double a)   返回最小的（最接近负无穷大）double值，该值大于等于参数，并等于某个整数。16.34->17
static double floor(double a)  与上边相反。16.34->16

static long round(double a)  返回最接近参数的long（四舍五入）  12.34->12  12.56->13

static double random()  返回带正号的double值（一个伪随机数），该值大于等于0.0，且小于1.0（0.0≤x<1.0）