JavaSE_jdk新特性_2-优快云博客

本文链接：https://blog.youkuaiyun.com/pre_eminent/article/details/17955887

NewMethod_JDK_Wrapper

package uncommitted;
import java.util.Arrays;

import org.junit.Test;
public class NewMethod_JDK_Wrapper {
   @Test
   public void method3() {
      /** 练习:对字符串中的数值从小到大进行排序*/
      String numStr="32,45,57,85,-3,64";
      final String SPERATOR=",";
      //String[] arr1=numStr.split(",");
      String[] arr1=numStr.split(SPERATOR);
      int len=arr1.length;
      int[] arr2=new int[len];
      for (int i = 0; i < len; i++) {
         arr2[i]=Integer.parseInt(arr1[i]);
         System.out.println(arr2[i]);
      }
      //使用数组工具的排序方法
      Arrays.sort(arr2);
      //传统的连接成串方法
      StringBuilder sb=new StringBuilder();
      sb.append("[");
      for (int i = 0; i < arr2.length; i++) {
         if(i!=arr2.length-1)
            //sb.append(arr2[i]+",");
            sb.append(arr2[i]+SPERATOR);
         else
            sb.append(arr2[i]+"]");
      }
      System.out.println(sb);
      //或者使用经典的数组toString
      //System.out.println(myToString(arr2));
   }
   //自定义将数组成员相连
    // 数组toString的经典实现!
    public String myToString(int[] a) {
         if (a == null)
             return "null";
         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(",");
         }
    }
    @Test
   public void method2() {
      Integer i1=new Integer("23");
      Integer i2=new Integer(23);
      System.out.println(i1==i2);//false因为==是两个地址
      System.out.println(i1.equals(i2));
      //true,因为Integer复写了equal方法,比较数值大小
      Integer i3=new Integer(60);
      Integer i4=new Integer(10);
      System.out.println(i1.compareTo(i2));
      //数值相等:0   在数值上比较两个Integer对象
      System.out.println(i1.compareTo(i3));
      //前<后: -1  在数值上比较两个Integer对象
      System.out.println(i1.compareTo(i4));
      //前>后: 1  在数值上比较两个Integer对象
      
      //自动装箱!
      Integer i5=new Integer(6);//JDK1.5以前
      Integer i6=6;//JDK1.5以后版本,自动装箱
      System.out.println(i5==i6);//false,地址不同,实际是两个NEW
      System.out.println(i5.equals(i6));
      //true,因为Integer复写了equal方法,比较数值大小
      System.out.println(i5.compareTo(i6));
      //数值相等:0   在数值上比较两个Integer对象
      i6=i6+9;
      //15,自动拆箱;重点~i6=new Integer(i6.intValue()+9);
      i6=new Integer(i6.intValue()+9);
      System.out.println(i6);//24
      //Integer i7=null;//注意:自动装箱时会出现NullPointerException
      Integer i7=7;
      System.out.println(i7+6);//13
      Integer i8=-128;
      //千万注意:自动装箱如果是1个字节大小,会共享数据
      //而不会重新开辟空间!!!
      Integer i9=-128;
      System.out.println(i8==i9);//true!!!-128~127
      System.out.println(i8.equals(i9));//true
   }
    @Test
   public void method1() {
      System.out.println(Integer.MAX_VALUE);//2147483647
      System.out.println(Integer.toBinaryString(-6));
      //11111111111111111111111111111010
      System.out.println(Integer.parseInt("123")+1);
      //124,如果格式不对,抛NumberFormatException
      Integer i1=new Integer("123");
      System.out.println(i1.intValue()+1);
      //返回124 value of this Integer as an int.
      System.out.println(Integer.toBinaryString(60));
      //十进制转2进制~111100
      System.out.println(Integer.toHexString(60));
      //3C
      System.out.println(Integer.toOctalString(60));
      //74
      System.out.println(Integer.toString(60));
      //60
      System.out.println(Integer.toString(60, 16));
      //3c,后面是radix进制,将整数转成指定进制的字符串
      Integer i2=Integer.valueOf(123);
      System.out.println(i2==Integer.valueOf(123));
      //true
      //其他进制到十进制,下面是把3C按16进制格式,转成十进制
      System.out.println(Integer.parseInt("3C", 16));
   }
}

GenericDemo1

package uncommitted;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.TreeSet;
import org.junit.Test;

import Collection.ComparatorByName;
import bean.Person;
import bean.Student;
import bean.Worker;
//<>表示数据的类型;简称泛型!
public class GenericDemo {
   @Test
   public void method7() {
      //下面演示泛型方法(非静态方法)
      GenericTools<String> tool=new GenericTools<String>();
      tool.show1("宝黛钗");
      //...show...宝黛钗
      
      tool.print("空对着;山中高士晶莹雪;终不忘;世外仙姝寂寞林;");
      //...print...空对着;山中高士晶莹雪;终不忘;世外仙姝寂寞林;
      
      //tool.show1(new Integer(4));//传1个整型对象就挂掉了!
      //因为show1和print方法都是使用(借用)的是泛型类里面的泛型(即同1个泛型)
      
      tool.showWithGeneric(new Integer(2014));
      //...showWithGeneric...2014    泛型定义在方法上面~
      
//      下面这个是静态的带泛型的方法,用类名直接调用!
      GenericTools.method_staticWithGeneric("叹人间;美中不足今方信");
      //...method_staticWithGeneric...叹人间;美中不足今方信
      
      GenericTools.method_staticWithGeneric(new Integer(2015));
      //...method_staticWithGeneric...2015
   }
   @Test
   public void method6() {
      // 泛型类演示! 这个是现在使用泛型后的代码!
      GenericTools<Student> tool=new GenericTools<Student>();
      tool.setQ(new Student("黛玉",16));
      //tool.setQ(new Worker());//在使用了泛型后,这个编译就不会通过了!
      Student stu=tool.getQ();
      System.out.println(stu);
      //Student:  黛玉...16
   }
   @Test
   public void method5() {
      // 泛型类演示! 现在是以前的做法!看!
      Tools tool=new Tools();
      tool.setObj(new Student());
      tool.setObj(new Worker());//如果是没有使用泛型,这里传个Worker进去,编译也不会报错,
      Student stu=(Student)tool.getObj();//运行时,才会报错ClassCastException
      System.out.println(stu);
   }
   @Test
   public void method4() {
      // TreeMap演示泛型,
      //排序使用的传参,一个实现比较器接口的类(策略模式)
      TreeSet<Person> ts=new TreeSet<Person>(new ComparatorByName());
      //Set保证元素唯一,但无序!
      ts.add(new Person("lisi6",20));
      ts.add(new Person("lisi2",22));
      ts.add(new Person("lisi3",23));
      Iterator<Person> it=ts.iterator();
      while (it.hasNext()) {
         //使用泛型避免强转
         Person p =  it.next();
         System.out.println(p.getName()+"..."+p.getAge());
      }      
      /*
      lisi2...22
      lisi3...23
      lisi6...20*/
   }
   @Test
   public void method3() {
      // TreeMap演示泛型,排序使用的是对象的compareTo()方法
      TreeSet<Person> ts=new TreeSet<Person>();//Set保证元素唯一,但无序!
      ts.add(new Person("lisi6",26));
      ts.add(new Person("lisi2",22));
      ts.add(new Person("lisi3",23));
      Iterator<Person> it=ts.iterator();
      while (it.hasNext()) {
         Person p =  it.next();
         System.out.println(p.getName()+"..."+p.getAge());
      }
      /*
      lisi2...22
      lisi3...23
      lisi6...20*/
   }
   @Test
   public void method2() {
//      这是运行泛型以后的写法,注意比较
//      int[] arr=new int[6];
      ArrayList<String> al=new ArrayList<String>();//集合声明的时候就要明确容器里面数据类型
      al.add("晴雯");
      al.add("香菱");
      al.add("袭人");
//      al.add(4);//自动装箱:new Integer(4),定义了泛型,这样写就会报错;
      Iterator<String> it=al.iterator();
      while (it.hasNext()) {
         String str =it.next();//不需要类型强转,只要编译通过,就不会运行时报错ClassCastException
         System.out.println(str);
      }      
      /*晴雯
      香菱
      袭人*/
   }
   public void method1() {
      //首先回顾一下小例子,这是以前的写法
      //好多黄色的叹号,全报raw type
      ArrayList al=new ArrayList();
      al.add("abc1");
      al.add("abc2");
      al.add("abc3");
      al.add(4);//自动装箱:new Integer(4);
      Iterator it=al.iterator();
      while (it.hasNext()) {
         String str = (String) it.next();//类型强转,编译OK,但运行时会报错ClassCastException
         System.out.println(str);
      }
   }
}

GenericDemo2

package uncommitted;
import org.junit.Test;

//将泛型定义在接口上,位置和类上的泛型一样,在名称的后面<T>
interface InterfaceWithGeneric<T> {
   public void show(T t);
}
//泛型接口的实现1:类在实现接口的时候就已经想好了类型!
class IntImp1 implements InterfaceWithGeneric<String>{
   public void show(String s){
      System.out.println(s);
   }
}
//泛型接口的实现2:类在实现接口的时候仍然没有想好用什么类型!
class IntImp2<W> implements InterfaceWithGeneric<W>{
   public void show(W s){
      System.out.println(s);
   }
}
public class GenericDemo2 {
   @Test
   public void method2() {
      /*类在实现接口的时候仍然没有想好用什么类型!(类仍沿用接口的泛型)
      而在实例化对象的时候才晓得该使用什么类型!*/
      IntImp2<Integer> i2=new IntImp2<Integer>();
      i2.show(new Integer(4));
   }
   @Test
   public void method1() {
      //类在实现泛型接口的时候就已经想好了要使用的类型(此为String)
      IntImp1 i1=new IntImp1();
      i1.show("想眼中能有多少泪珠儿;怎经得秋流到冬尽;春流到夏！");
//      i1.show(new Integer(4));报错,因为类IntImp1在实现接口的时候就已经规定好了类型!
   }
}

GenericDemo3

package uncommitted;

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

import org.junit.Test;

import bean.Person;
import bean.Student;
import bean.Worker;

//Eclipse快捷键:导入包:ctrl +shift+O
public class GenericDemo3 {
   @Test
   public void method5() {
      // 默认是按已实现Comparable接口的Person类的compareTo方法自然排序(按年龄排序);
      TreeSet<Person> ts1 = new TreeSet<Person>();
      ts1.add(new Person("袭人", 19));
      ts1.add(new Person("宝玉", 17));
      ts1.add(new Person("黛玉", 16));
      ts1.add(new Person("宝钗", 18));
      Iterator<Person> it = ts1.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
      /*
       * 黛玉...16 宝玉...17 宝钗...18 袭人...19
       */
   }

   @Test
   public void method4() {
      /*
       * 一般在往集合里面增加(存入)的时候用的是上限(即父类)!!! 即排除掉那些不符合条件的元素,防止它们进来, 只允许同类及子类进入集合,
       * 取出元素操作的时候(都是按父类的方法操作), 所以不会出现方法不适合等错误!
       */
      ArrayList<Person> a1 = new ArrayList<Person>();
      a1.add(new Person("宝玉", 17));
      a1.add(new Person("黛玉", 16));

      ArrayList<Student> a2 = new ArrayList<Student>();
      a2.add(new Student("香菱", 19));

      ArrayList<Worker> a3 = new ArrayList<Worker>();
      a3.add(new Worker("袭人", 18));
      a3.add(new Worker("鸳鸯", 18));
      /*
       * 下面就把a3集合(Worker)一次全部添加到a1集合(Person)里面去, OK,没有问题!因为a3集合中的Worker继承自a1集合<Person>,
       * 是的a1集合子类!所以以后要取元素的时候, 按上限(即父类)的方法来进行取出等操作的时, 就不会出现任何问题!
       */
      a1.addAll(a3);
      System.out.println(a1.get(1));
      // 黛玉...16
   }

   @Test
   public void method3() {
      // 我只想打印出Student及其父类
      ArrayList<Worker> work_list = new ArrayList<Worker>();
      work_list.add(new Worker("鸳鸯", 18));
      work_list.add(new Worker("袭人", 18));
      ArrayList<Student> stu_list = new ArrayList<Student>();
      stu_list.add(new Student("香菱", 19));
      ArrayList<Person> person_list = new ArrayList<Person>();
      person_list.add(new Person("宝玉", 17));
      person_list.add(new Person("黛玉", 16));
      /*
       * showSuperOfStudent(work_list); 由于showSuperOfStudent方法人的参数:
       * 限定了list集合的成员只能是Student的父类, 所以传Worker会报错!
       */
      showSuperOfStudent(stu_list);
      showSuperOfStudent(person_list);
   }

   // 自定义方法:只打印出Student及其父类
   public void showSuperOfStudent(Collection<? super Student> coll) {
      Iterator<? super Student> it = coll.iterator();
      while (it.hasNext()) {
         /*
          * Person p=it.next();不能再这样转了 因为Object也是Student的超类,
          * 所以万万不能再用Person接收了!
          * System.out.println(p.getName()+"..."+p.getAge());
          * 同样,也不能再用Person的方法了
          */
         System.out.println(it.next());
      }
   }

   @Test
   public void method2() {
      // 只想打印出Person及其子类
      ArrayList<Worker> work_list = new ArrayList<Worker>();
      work_list.add(new Worker("鸳鸯", 18));
      work_list.add(new Worker("袭人", 18));
      ArrayList<Student> stu_list = new ArrayList<Student>();
      stu_list.add(new Student("香菱", 19));
      ArrayList<Integer> int_list = new ArrayList<Integer>();
      int_list.add(2013);
      int_list.add(2014);
      showSubOfPerson(work_list);
      showSubOfPerson(stu_list);
      /* showSubOfPerson(int_list);
      第3个集合会直接报错!
      因为已经限定? extends Person
      而Integer并不是的Person子类*/
   }
   // 自定义方法:只打印出Person及其子类
   //参数是个集合,并且集合的成员只允许是Person的子类
   public void showSubOfPerson(Collection<? extends Person> coll) {
      Iterator<? extends Person> it = coll.iterator();
      while (it.hasNext()) {
         //因为所有成员都规定了是Person的子类
         //所以,可以用超类Person接收~
         //并且,可以调用超类Person的方法
         Person p = it.next();
         System.out.println(p.getName() + "..." + p.getAge());
      }
   }
   @Test
   public void method1() {
      // 等号左右两边的泛型必须匹配!
      ArrayList<String> 咏白海棠 = new ArrayList<String>();
      咏白海棠.add("半卷湘帘半掩门");
      咏白海棠.add("碾冰为土玉为盆");
      咏白海棠.add("偷来梨蕊三分白");
      咏白海棠.add("借得梅花一缕魂");
      咏白海棠.add("月窟仙人缝缟袂");
      咏白海棠.add("秋闺怨女拭啼痕");
      咏白海棠.add("娇羞默默同谁诉");
      咏白海棠.add("倦倚西风夜已昏");
      ArrayList<Integer> a2 = new ArrayList<Integer>();
      a2.add(2013);
      a2.add(2014);
      printCollection(咏白海棠);
      printCollection(a2);
      /*半卷湘帘半掩门
      碾冰为土玉为盆
      偷来梨蕊三分白
      借得梅花一缕魂
      月窟仙人缝缟袂
      秋闺怨女拭啼痕
      娇羞默默同谁诉
      倦倚西风夜已昏
      2013
      2014*/
   }

   // 将打印(迭代)抽取为方法,提高复用!并且为了接收更多的参数进来,将方法printCollection中的参数ArrayList,改成其父类Collection
   // 通配符<?>代表接收任意类型的参数
   public void printCollection(Collection<?> coll) {
      Iterator<?> it = coll.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
   }
   
    // 一旦把通配符<?>改成了<T>,那么T就可以参与运算,还可以作为参数返回 
   public <T> T printCollection2(Collection<T> coll) {
      Iterator<T> it = coll.iterator();
      while (it.hasNext()) {
         T t = it.next();
         if (t.toString() == "")
            return t;
      }
      return null;
   }
    
   
     public void showCollection(Collection<String> coll) {
      Iterator<String> it = coll.iterator();
      while (it.hasNext()) {
         //不需强转
         String str = it.next();
         System.out.println(str);
      }
   }
    
}

GenericDemo4

package uncommitted;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

import org.junit.Test;

import bean.Person;
import bean.Student;
public class GenericDemo4 {
   @Test
   public void method3() {
      /*下面按比较器<Person的比较方式>,对学生<Student>按姓名排序,这是可以的!
      因为Person是Student的父类,
      要求是:TreeSet<E>,比较器应该是<? super E>,
      即集合中的成员,使用其父类的方法,进行比较~
      即用E的父类<Person>来接收两个比较的对象<Student>,多态!
      比如下面这个:E是Student,比较器是Person,
      即用Person用为参数接收被比较的Student对象,多态!
      父类引用指向子类的实例!调用的还是子类的方法!
      TreeSet(Comparator<? super E> comparator) 
        构造一个新的空 TreeSet，它根据指定比较器进行排序。*/
      TreeSet<Student> ts1=new TreeSet<Student>(new CompByName());
      ts1.add(new Student("Student2",34));
      ts1.add(new Student("Student6",30));
      ts1.add(new Student("Student3",38));
      Iterator<Student> it=ts1.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
      /*Student:  Student2...34
      Student:  Student3...38
      Student:  Student6...30*/
   }
   @Test
   public void method2() {
      //下面是按比较器<Person>,即姓名排序
      TreeSet<Person> ts1=new TreeSet<Person>(new CompByName());
      ts1.add(new Person("person4",34));
      ts1.add(new Person("person1",30));
      ts1.add(new Person("person2",38));
      Iterator<Person> it=ts1.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
   }
   @Test
   public void method1() {
      // 默认是按已实现Comparable接口的Person类的compareTo方法自然排序(按年龄排序);
            TreeSet<Person> ts1=new TreeSet<Person>();
            ts1.add(new Person("黛玉",16));
            ts1.add(new Person("宝琴",15));
            ts1.add(new Person("宝玉",17));
            ts1.add(new Person("宝钗",18));
            Iterator<Person> it=ts1.iterator();
            while (it.hasNext()) {
               System.out.println(it.next());
            }
            /*宝琴...15
            黛玉...16
            宝玉...17
            宝钗...18*/
   }
}
/*下面就写个比较器类!来实现按姓名排序
泛型规定的是Person,
所以凡是Person的子类都可以(传进来,多态)
根据此比较器进行比较~*/
class CompByName implements Comparator<Person>{
   public int compare(Person o1, Person o2) {
      //根据Unicode value of each character in the strings排序
      int temp=o1.getName().compareTo(o2.getName());
      return temp==0?o1.getAge()-o2.getAge():temp;
   }
}