JavaSE_jdk新特性_2
来源：互联网 发布：智者软件官网 编辑：程序博客网 时间：2024/06/08 11:58
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+Opublic 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; }} 0 0
- JavaSE_jdk新特性_2
- JavaSE_jdk新特性
- java高级特性_2
- 总结1_2：常见Unity特性
- 新特性
- 新特性
- 新特性
- 新特性
- apue习题9_2建立新会话
- Java新特性：接口新特性
- HTML5开发笔记_2、HTML5基础_1.HTML5特性简介
- 7.0新特性新1
- delphi6的新特性
- Oracle9i新特性：iSQLPLUS
- J2SE 5.0 新特性
- ejb3.0新特性
- Java1.5新特性
- Oracle9i新特性：iSQLPLUS
- 基于bt开发的工具选择
- Centos6.0之rsyslog部署日志服务器
- 工作5天了。。。稍微有点熟悉这个框架了。。（这个是递归删除部门。）
- 引用web service时，出现无法识别的配置节点applicationSettings(程序报500错误)
- 最基本的百度算法秘密，了解后减少一个月的优化时间！
- JavaSE_jdk新特性_2
- SQL Server 中的 NOLOCK 到底是什么意思
- opencv2.4.7.2画圆，画十字，画矩形
- Android: NDK编程入门笔记
- RL-RTX小读之os_sem_wait
- SQL Server 列转行存储过程
- 面试经2
- mysql：21个性能优化最佳实践之3[当只要一行数据时使用 LIMIT 1]
- IE6下注释引起的文字溢出和浮动错位
