Java学习笔记(Javase毕向东版视频)六 常用API对象二

 1 public class Test {
 2     public static void main(String[] args){
 3         Demo();
 4         toStringDemo();
 5         jdkDemo();
 6     }
 7     
 8     private static void jdkDemo() {
 9         //注意:在1.5之后的版本中可以使用下面的形式  简化书写  ,这是版本升级的一个方面
10         Integer i=3;    //自动装箱,jdk是Integer i = Integer.valueOf(3);
11         i=i+3;            //自动拆箱,
12         /*注意:和用new生成对象的小区别是,
13          * 简写书写时如果数值在一个字节以内(即<128)时,重复生成不产生新空间
14          */
15         Integer a=127;
16         Integer b=127;
17         System.out.println(a==b);
18         System.out.println(a.equals(b));
19         Integer c=128;
20         Integer d=128;
21         System.out.println(c==d);
22         System.out.println(c.equals(d));
23     }
24 
25     static void Demo(){
26         /*1、获取对象包装器类,以Integer为例:
27          * 最简单的是使用new,可以传入一个本类的基本数据和""包含的本类基本数据
28          * 注意:如果""中包含的不是本类基本数据会抛出一个运行时异常
29          */
30         Integer a=new Integer(3);
31         Integer b=new Integer("3");
32         
33         //2、也可以使用静态方法valueOf()来获取对象包装类对象实例
34 //        Integer c=Integer.valueOf("3");
35 //        Integer d=Integer.valueOf("3", 10);        //第二个参数指定进制
36 //        Integer e=Integer.valueOf(3);            //这是1.5版本后新增的
37         
38         //3、当然也可以将包装类对象转换为基本类型,注意不仅可以是本类基本类型,还可以是其他基本类型(但不是所有的)
39 //        int f=a.intValue();
40 //        byte g=a.byteValue();
41         
42         //4、基本类型封装成对象之后的比较
43         System.out.println(a==b);            //比较地址
44         System.out.println(a.equals(b));    //比较是否相等
45         System.out.println(a.compareTo(b)); //比较大小(根据字典顺序)
46     }
47 
48     private static void toStringDemo() {
49         //对象包装类的一个主要作用就是将基本数据类型和String类型互换
50         //1、基本类型转换为String类型
51         Integer i=new Integer(60);
52         //使用静态方法
53         System.out.println(Integer.toString(i));
54         System.out.println(Integer.toString(i, 16));
55         //
56         System.out.println(i.toString());
57         //Integer类还可以选择特定的进制进行转换,如2进制,8进制,16进制。是静态方法,内部调用toSting()
58         System.out.println(Integer.toBinaryString(i));
59         
60         //2、String转换为基本类型
61         String s="60";
62         System.out.println(Integer.parseInt(s));
63             //！！！下面的进制是将字符串当做该进制的数进行解析,返回一个10进制的数
64         s="3c";
65         System.out.println(Integer.parseInt(s,16));
66     }
67 }

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.ListIterator;
 4 
 5 public class CollectionInterface {
 6     public static void main(String[] args){
 7         Demo();
 8         iteratorDemo();
 9         listDemo();
10         ListIteratorDemo();
11     }
12 
13     public static void Demo() {
14         ArrayList a1=new ArrayList();
15         ArrayList a2=new ArrayList();
16         a1.add("asd1");
17         a1.add("asd2");
18         a2.add("asd2");
19         a2.add("asd3");
20         System.out.println("a1="+a1);
21         System.out.println("a2="+a2);
22         //注意:addAll()会将指定集合所有对象都添加,即使用重复的也会添加
23         a1.addAll(a2);
24         System.out.println("a1="+a1);
25         //注意:removeAll()会将指定集合所有对象都删除,！！！两者中共有的也会删除
26         a1.removeAll(a2);
27         System.out.println("a1="+a1);
28         //retainAll()和removeAll()相反,会将指定集合所有对象都保存,而把其他全删除
29     }
30 
31     public static void iteratorDemo() {
32         ArrayList a1=new ArrayList();
33         a1.add("asd1");
34         a1.add("asd2");
35         a1.add("asd3");
36         a1.add("asd4");
37         /*迭代器是集合容器用来取元素的方法,不同集合有不同的取法,所以具体的迭代器依赖于具体容器,
38          * ！！！Java只提供一个接口,每一个容器都需要将其作为    内部类   实现用以获取元素即可
39          * 使用iterator()获取一个迭代器,并用该迭代器获取集合中对象,
40          * 迭代器Iterator接口有三个方法:
41          * 1、hasNext():检测是否有下一个元素,因为获取方法不检测是否超过集合容量,超过会报错
42          * 2、next():获取下一个元素
43          * 3、remove():删除元素
44          */
45 //        Iterator i=a1.iterator();
46 //        while(i.hasNext()){
47 //            System.out.println(i.next());
48 //        }
49 //    ！！！使用while循环的缺点是在循环遍历后,该迭代器已经不能去除任何值,但仍可以使用,浪费空间,可改为for循环
50         for(Iterator i=a1.iterator();i.hasNext();){
51             System.out.println(i.next());
52         }
53     }
54 
55     private static void listDemo() {
56         //List集合的特有方法:由于List集合中元素有角标,！！！所以特殊方法就是利用角标来进行增删改查
57         //注意 改 的方法在Collection中没有
58         ArrayList a=new ArrayList();
59         //普通添加和指定位置添加
60         a.add("asd2");
61         System.out.println("a="+a);
62         a.add(0,"asd3");
63         System.out.println("a="+a);
64         //修改指定位置元素,set()返回值是原来该位置的元素
65         System.out.println("被删除的元素是:"+a.set(0,"asd1"));
66         System.out.println("a="+a);
67     }
68 
69     private static void ListIteratorDemo() {
70         ArrayList a1=new ArrayList();
71         a1.add("asd1");
72         a1.add("asd2");
73         a1.add("asd3");
74 //        Iterator i=a1.iterator();
75 //        while(i.hasNext()){
76 //            Object obj=i.next();
77 //            if(obj=="asd3"){
78 //                a1.add("asd5");
79 //            }else{
80 //                System.out.println(i.next());
81 //            }    
82 //        }
83         /*在使用迭代器Iterator接口时,!!!不能同时进行增/删/改的操作,
84          * 会报ConcurrentModificationException异常。
85          * 可以使用子接口ListIterator接口代替,！！！由名字可以看出只在List集合中使用
86          * ListIterator还允许逆向遍历List,使用hasPrevious()
87          */
88         ListIterator i=a1.listIterator();
89         while(i.hasNext()){
90             Object obj=i.next();
91             if(obj=="asd3"){
92                 i.add("asd4");
93             }else{
94                 System.out.println(i.next());
95             }    
96         }
97         System.out.println("a1="+a1);
98     }
99 }

 1 public class Person implements Comparable<Person>{
 2     private int age;
 3     public Person(int age, String name) {
 4         super();
 5         this.age = age;
 6         this.name = name;
 7     }
 8     private String name;
 9     public int getAge() {
10         return age;
11     }
12     public void setAge(int age) {
13         this.age = age;
14     }
15     public String getName() {
16         return name;
17     }
18     public void setName(String name) {
19         this.name = name;
20     }
21     //这里的重写是为了HastSet练习使用
22     @Override
23     public int hashCode() {
24         return name.hashCode()+age;
25     }
26     @Override
27     public boolean equals(Object obj) {
28         Person p=(Person)obj;
29         return this.name.equals(p.name)&&(this.age==p.age);
30     }
31     //这里的 重写是为了TreeSet练习使用
32     @Override
33     public int compareTo(Person o) {
34         //注意适用泛型后不需要在进行类型强转
35         int count=0;
36         if(o instanceof Person){
37             Person p=(Person)o;
38 //            if(this.age>p.age){
39 //                return 1;
40 //            }else if(this.age<p.age){
41 //                return -1;
42 //            }else{
43 //                return this.name.compareTo(p.name);
44 //            }
45             return count=this.age-p.age==0?this.name.compareTo(p.name):count;
46         }
47         return 0;
48     }
49     
50 }

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.LinkedList;
 4 import com.lll.cn.Person;
 5 
 6 public class ListSubClassDemo {
 7     public static void main(String[] args){
 8         VectorDemo();
 9         LinkedListDemo();
10         LinkedListTest();
11         ArrayListDemo();
12     }
13 
14     public static void VectorDemo() {
15         //该类由于效率低下,和Enumeration一起不推荐使用
16     }
17 
18     public static void LinkedListDemo() {
19         /*LinkedList是链表结构,所以特殊方法是和第一个元素/最后一个元素相关
20          * 如在第一个/最后一个位置添加元素,删除元素,获取元素等
21          * ！！！注意有些方法仅仅获取,有些是移除并返回
22          * 注意:
23          */
24         LinkedList<String> l=new LinkedList<String>();
25         l.add("asd2");
26         l.add("asd3");
27         l.addFirst("asd1");
28         System.out.println("最后一个元素是"+l.getLast());
29         while(!l.isEmpty()){
30             System.out.println(l.removeFirst());
31         }
32         System.out.println(l);
33     }
34 
35     public static void LinkedListTest() {
36         /*使用LinkedList模拟堆栈和队列两种数据结构
37          * 堆栈:先进后出First In Last Out  -->FILO
38          * 队列:先进先出First In First Out -->FIFO 
39          */
40         StackDemo q=new StackDemo();
41         q.myAdd("asd9");
42         q.myAdd("asd2");
43         q.myAdd("asd3");
44         q.myAdd("asd4");
45         System.out.println(q.myRemove());
46     }
47 
48     private static void ArrayListDemo() {
49         //ArrayList集合是最常用的的集合,并且通常用于存储自定义对象
50         ArrayList<Person> a=new ArrayList<Person>();
51         a.add(new Person(11,"asd1"));
52         a.add(new Person(12,"asd2"));
53         a.add(new Person(13,"asd3"));
54         a.add(new Person(14,"asd4"));
55         /*！！！注意在使用集合存储数据时的易错点
56          * 1、所有自定义类型都会转换为Object类型,所以在使用时应该进行强制转换
57          * 2、在一个循环中使用next()时应该小心,因为每次next()都会将指针向下移动而不再指向刚才对象
58          * 下面就是错误示例
59          */
60         for (Iterator<Person> i = a.iterator(); i.hasNext();) {
61             //System.out.println(i.next().getName()+i.next().getAge());
62             Person p=(Person) i.next();
63             System.out.println(p.getName()+":"+p.getAge());
64             
65         }
66     }
67 }
68 class QueueDemo{
69     private LinkedList<Person> l=null;
70     QueueDemo(){
71         l=new LinkedList<Person>();
72     }
73     public void myAdd(Person obj){
74         l.add(obj);
75     }
76     public Object myRemove(){
77         return l.removeFirst();
78     }
79 }
80 class StackDemo{
81     private LinkedList<String> l=null;
82     StackDemo(){
83         l=new LinkedList<String>();
84     }
85     public void myAdd(String obj){
86         l.add(obj);
87     }
88     public Object myRemove(){
89         return l.removeLast();
90     }
91 }

 1 import java.util.HashSet;
 2 import java.util.Iterator;
 3 import java.util.LinkedHashSet;
 4 import java.util.TreeSet;
 5 
 6 import com.lll.cn.Person;
 7 
 8 public class SetSubDemo {
 9     public static void main(String[] args){
10         HashSetDemo();
11         HastSetTest();
12         TreeSetDemo();
13     }
14 
15     public static void HashSetDemo() {
16         /*HashSet的底层结构仍是数组,但是有所改进:
17          * 即存入数据时是根据哈希算法获取该数据的地址值,然后将其存入该地址
18          * 特点:
19          * 1、不允许存入相同元素,
20          * 2、如果计算出两个相同地址值,会将后者进行修改后存储
21          * 3、获取时计算地址值,如果该位置有元素且
22          * ！！！注意确定对象地址值的哈希算法就是对象内部的hashCode(),如果没有则使用继承自Object的
23          * 所以要使用HashSet来存储数据,并保证其中的值唯一,应该修改hashCode()和equals()
24          * 
25          * ！！！在集合中对一个元素进行操作(例如remove,contains),首要的是判断在集合中是否有该对象,
26          * 通常依靠的是equals()和hashCode()。所以使用自定义对象时,应该对这两个方法进行重写
27          */
28     }
29 
30     public static void HastSetTest() {
31         HashSet<Person> hs=new HashSet<Person>();
32         //如果自定义对象也要达到确保唯一性的要求,就要覆写hashCode()和equals(),原因见上
33         hs.add(new Person(11,"asd1"));
34         hs.add(new Person(12,"asd2"));
35         hs.add(new Person(13,"asd3"));
36         hs.add(new Person(14,"asd4"));
37         hs.add(new Person(11,"asd1"));
38         for (Iterator<Person> i = hs.iterator(); i.hasNext();) {
39             Person obj = (Person) i.next();
40             System.out.println(obj.getName()+":"+obj.getAge());
41         }
42         //HashSet还有一个子类LinkedHashSet,具有LinkedList和HashSet双重特性:即有序又唯一
43         LinkedHashSet<Person> lhs=new LinkedHashSet<Person>();
44         lhs.add(new Person(11,"asd1"));
45         lhs.add(new Person(12,"asd2"));
46         lhs.add(new Person(13,"asd3"));
47         lhs.add(new Person(14,"asd4"));
48         lhs.add(new Person(11,"asd1"));
49         for (Iterator<Person> i = lhs.iterator(); i.hasNext();) {
50             Person obj = (Person) i.next();
51             System.out.println(obj.getName()+":"+obj.getAge());
52         }
53     }
54 
55     public static void TreeSetDemo() {
56         /*TreeSet集合会对存入的对象进行比较然后进行存放,比较的过程可以用以下两种方式实现
57          * 1、使对象实现Comparable借口,重写compareTo(),称为自然排序方法
58          * 2、使集合具备排序功能,就是向TreeSet中传入一个实现了Comparator接口的类的对象实例
59          */
60         TreeSet<Person> ts=new TreeSet<Person>();
61         ts.add(new Person(21,"asd1"));
62         ts.add(new Person(22,"asd2"));
63         ts.add(new Person(22,"asd3"));
64         ts.add(new Person(24,"asd4"));
65         for (Iterator<Person> i = ts.iterator(); i.hasNext();) {
66             Person p = (Person) i.next();
67             System.out.println(p.getName()+":"+p.getAge());
68         }
69         TreeSet<Person> ts2=new TreeSet<Person>(new ComparatorByName());
70         ts2.add(new Person(21,"asd1"));
71         ts2.add(new Person(22,"asd2"));
72         ts2.add(new Person(22,"asd3"));
73         ts2.add(new Person(24,"asd1"));
74         for (Iterator<Person> i = ts2.iterator(); i.hasNext();) {
75             Person p = (Person) i.next();
76             System.out.println(p.getName()+":"+p.getAge());
77         }
78     }
79 }

 1 import java.util.Comparator;
 2 
 3 import com.lll.cn.Person;
 4 
 5 public class ComparatorByName implements Comparator<Person>
 6 {
 7     //这个类是外部类,用于集合中元素的比较
 8     @Override
 9     public int compare(Person p1, Person p2)
10     {
11         int comp=0;
12         
13         return (comp=p1.getName().compareTo(p2.getName()))!=0?comp:p1.getAge()-p2.getAge();
14         //return 1;
15     }
16 }