Java学习笔记六 常用API对象二

1、基本数据类型对象包装类:见下图

 public class Test {
     public static void main(String[] args){
         Demo();
         toStringDemo();
         jdkDemo();
     }
 
     private static void jdkDemo() {
         //注意:在1.5之后的版本中可以使用下面的形式  简化书写  ,这是版本升级的一个方面
         Integer i=3;    //自动装箱,jdk是Integer i = Integer.valueOf(3);
         i=i+3;            //自动拆箱,
         /*注意:和用new生成对象的小区别是,
          * 简写书写时如果数值在一个字节以内(即<128)时,重复生成不产生新空间
          */
         Integer a=127;
         Integer b=127;
         System.out.println(a==b);
         System.out.println(a.equals(b));
         Integer c=128;
         Integer d=128;
         System.out.println(c==d);
         System.out.println(c.equals(d));
     }
 
     static void Demo(){
         /*1、获取对象包装器类,以Integer为例:
          * 最简单的是使用new,可以传入一个本类的基本数据和""包含的本类基本数据
          * 注意:如果""中包含的不是本类基本数据会抛出一个运行时异常
          */
         Integer a=new Integer(3);
         Integer b=new Integer("3");
 
         //2、也可以使用静态方法valueOf()来获取对象包装类对象实例
 //        Integer c=Integer.valueOf("3");
 //        Integer d=Integer.valueOf("3", 10);        //第二个参数指定进制
 //        Integer e=Integer.valueOf(3);            //这是1.5版本后新增的
 
         //3、当然也可以将包装类对象转换为基本类型,注意不仅可以是本类基本类型,还可以是其他基本类型(但不是所有的)
 //        int f=a.intValue();
 //        byte g=a.byteValue();
 
         //4、基本类型封装成对象之后的比较
         System.out.println(a==b);            //比较地址
         System.out.println(a.equals(b));    //比较是否相等
         System.out.println(a.compareTo(b)); //比较大小(根据字典顺序)
     }
 
     private static void toStringDemo() {
         //对象包装类的一个主要作用就是将基本数据类型和String类型互换
         //1、基本类型转换为String类型
         Integer i=new Integer(60);
         //使用静态方法
         System.out.println(Integer.toString(i));
         System.out.println(Integer.toString(i, 16));
         //
         System.out.println(i.toString());
         //Integer类还可以选择特定的进制进行转换,如2进制,8进制,16进制。是静态方法,内部调用toSting()
         System.out.println(Integer.toBinaryString(i));
 
         //2、String转换为基本类型
         String s="60";
         System.out.println(Integer.parseInt(s));
             //！！！下面的进制是将字符串当做该进制的数进行解析,返回一个10进制的数
         s="3c";
         System.out.println(Integer.parseInt(s,16));
     }
 }

基本类型对象包装类

参考:自动装箱

http://openhome.cc/Gossip/Java/AutoBoxUnBox.html

http://www.cnblogs.com/danne823/archive/2011/04/22/2025332.html

2、集合类:

！！！集合框架图：

Collection接口和List接口的方法:

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.ListIterator;
 
 public class CollectionInterface {
     public static void main(String[] args){
         Demo();
         iteratorDemo();
         listDemo();
         ListIteratorDemo();
     }
 
     public static void Demo() {
         ArrayList a1=new ArrayList();
         ArrayList a2=new ArrayList();
         a1.add("asd1");
         a1.add("asd2");
         a2.add("asd2");
         a2.add("asd3");
         System.out.println("a1="+a1);
         System.out.println("a2="+a2);
         //注意:addAll()会将指定集合所有对象都添加,即使用重复的也会添加
         a1.addAll(a2);
         System.out.println("a1="+a1);
         //注意:removeAll()会将指定集合所有对象都删除,！！！两者中共有的也会删除
         a1.removeAll(a2);
         System.out.println("a1="+a1);
         //retainAll()和removeAll()相反,会将指定集合所有对象都保存,而把其他全删除
     }
 
     public static void iteratorDemo() {
         ArrayList a1=new ArrayList();
         a1.add("asd1");
         a1.add("asd2");
         a1.add("asd3");
         a1.add("asd4");
         /*迭代器是集合容器用来取元素的方法,不同集合有不同的取法,所以具体的迭代器依赖于具体容器,
          * ！！！Java只提供一个接口,每一个容器都需要将其作为    内部类   实现用以获取元素即可
          * 使用iterator()获取一个迭代器,并用该迭代器获取集合中对象,
          * 迭代器Iterator接口有三个方法:
          * 1、hasNext():检测是否有下一个元素,因为获取方法不检测是否超过集合容量,超过会报错
          * 2、next():获取下一个元素
          * 3、remove():删除元素
          */
 //        Iterator i=a1.iterator();
 //        while(i.hasNext()){
 //            System.out.println(i.next());
 //        }
 //    ！！！使用while循环的缺点是在循环遍历后,该迭代器已经不能去除任何值,但仍可以使用,浪费空间,可改为for循环
         for(Iterator i=a1.iterator();i.hasNext();){
             System.out.println(i.next());
         }
     }
 
     private static void listDemo() {
         //List集合的特有方法:由于List集合中元素有角标,！！！所以特殊方法就是利用角标来进行增删改查
         //注意 改 的方法在Collection中没有
         ArrayList a=new ArrayList();
         //普通添加和指定位置添加
         a.add("asd2");
         System.out.println("a="+a);
         a.add(0,"asd3");
         System.out.println("a="+a);
         //修改指定位置元素,set()返回值是原来该位置的元素
         System.out.println("被删除的元素是:"+a.set(0,"asd1"));
         System.out.println("a="+a);
     }
 
     private static void ListIteratorDemo() {
         ArrayList a1=new ArrayList();
         a1.add("asd1");
         a1.add("asd2");
         a1.add("asd3");
 //        Iterator i=a1.iterator();
 //        while(i.hasNext()){
 //            Object obj=i.next();
 //            if(obj=="asd3"){
 //                a1.add("asd5");
 //            }else{
 //                System.out.println(i.next());
 //            }
 //        }
         /*在使用迭代器Iterator接口时,!!!不能同时进行增/删/改的操作,
          * 会报ConcurrentModificationException异常。
          * 可以使用子接口ListIterator接口代替,！！！由名字可以看出只在List集合中使用
          * ListIterator还允许逆向遍历List,使用hasPrevious()
          */
         ListIterator i=a1.listIterator();
         while(i.hasNext()){
             Object obj=i.next();
             if(obj=="asd3"){
                 i.add("asd4");
             }else{
                 System.out.println(i.next());
             }
         }
         System.out.println("a1="+a1);
     }
 }

Collection练习

下面是List接口的常用子类:

 public class Person implements Comparable<Person>{
     private int age;
     public Person(int age, String name) {
         super();
         this.age = age;
         this.name = name;
     }
     private String name;
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     //这里的重写是为了HastSet练习使用
     @Override
     public int hashCode() {
         return name.hashCode()+age;
     }
     @Override
     public boolean equals(Object obj) {
         Person p=(Person)obj;
         return this.name.equals(p.name)&&(this.age==p.age);
     }
     //这里的 重写是为了TreeSet练习使用
     @Override
     public int compareTo(Person o) {
         //注意适用泛型后不需要在进行类型强转
         int count=0;
         if(o instanceof Person){
             Person p=(Person)o;
 //            if(this.age>p.age){
 //                return 1;
 //            }else if(this.age<p.age){
 //                return -1;
 //            }else{
 //                return this.name.compareTo(p.name);
 //            }
             return count=this.age-p.age==0?this.name.compareTo(p.name):count;
         }
         return 0;
     }
 
 }

Person类

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.LinkedList;
 import com.lll.cn.Person;
 
 public class ListSubClassDemo {
     public static void main(String[] args){
         VectorDemo();
         LinkedListDemo();
         LinkedListTest();
         ArrayListDemo();
     }
 
     public static void VectorDemo() {
         //该类由于效率低下,和Enumeration一起不推荐使用
     }
 
     public static void LinkedListDemo() {
         /*LinkedList是链表结构,所以特殊方法是和第一个元素/最后一个元素相关
          * 如在第一个/最后一个位置添加元素,删除元素,获取元素等
          * ！！！注意有些方法仅仅获取,有些是移除并返回
          * 注意:
          */
         LinkedList<String> l=new LinkedList<String>();
         l.add("asd2");
         l.add("asd3");
         l.addFirst("asd1");
         System.out.println("最后一个元素是"+l.getLast());
         while(!l.isEmpty()){
             System.out.println(l.removeFirst());
         }
         System.out.println(l);
     }
 
     public static void LinkedListTest() {
         /*使用LinkedList模拟堆栈和队列两种数据结构
          * 堆栈:先进后出First In Last Out  -->FILO
          * 队列:先进先出First In First Out -->FIFO
          */
         StackDemo q=new StackDemo();
         q.myAdd("asd9");
         q.myAdd("asd2");
         q.myAdd("asd3");
         q.myAdd("asd4");
         System.out.println(q.myRemove());
     }
 
     private static void ArrayListDemo() {
         //ArrayList集合是最常用的的集合,并且通常用于存储自定义对象
         ArrayList<Person> a=new ArrayList<Person>();
         a.add(new Person(11,"asd1"));
         a.add(new Person(12,"asd2"));
         a.add(new Person(13,"asd3"));
         a.add(new Person(14,"asd4"));
         /*！！！注意在使用集合存储数据时的易错点
          * 1、所有自定义类型都会转换为Object类型,所以在使用时应该进行强制转换
          * 2、在一个循环中使用next()时应该小心,因为每次next()都会将指针向下移动而不再指向刚才对象
          * 下面就是错误示例
          */
         for (Iterator<Person> i = a.iterator(); i.hasNext();) {
             //System.out.println(i.next().getName()+i.next().getAge());
             Person p=(Person) i.next();
             System.out.println(p.getName()+":"+p.getAge());
 
         }
     }
 }
 class QueueDemo{
     private LinkedList<Person> l=null;
     QueueDemo(){
         l=new LinkedList<Person>();
     }
     public void myAdd(Person obj){
         l.add(obj);
     }
     public Object myRemove(){
         return l.removeFirst();
     }
 }
 class StackDemo{
     private LinkedList<String> l=null;
     StackDemo(){
         l=new LinkedList<String>();
     }
     public void myAdd(String obj){
         l.add(obj);
     }
     public Object myRemove(){
         return l.removeLast();
     }
 }

ListSubClassDemo练习

迭代器接口(Iterator):用于获取容器中的元素,是枚举类(Enumeration)的改进版,增加了删除功能并简化了书写。枚举类是伴随着Vector类的出现而出现的,也伴随着该类的改进(使用ArrayList代替)而被改进(使用Iterator代替)

链表和数组:

LinkedList特有方法:

Set常用子类:

 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.TreeSet;
 
 import com.lll.cn.Person;
 
 public class SetSubDemo {
     public static void main(String[] args){
         HashSetDemo();
         HastSetTest();
         TreeSetDemo();
     }
 
     public static void HashSetDemo() {
         /*HashSet的底层结构仍是数组,但是有所改进:
          * 即存入数据时是根据哈希算法获取该数据的地址值,然后将其存入该地址
          * 特点:
          * 1、不允许存入相同元素,
          * 2、如果计算出两个相同地址值,会将后者进行修改后存储
          * 3、获取时计算地址值,如果该位置有元素且
          * ！！！注意确定对象地址值的哈希算法就是对象内部的hashCode(),如果没有则使用继承自Object的
          * 所以要使用HashSet来存储数据,并保证其中的值唯一,应该修改hashCode()和equals()
          *
          * ！！！在集合中对一个元素进行操作(例如remove,contains),首要的是判断在集合中是否有该对象,
          * 通常依靠的是equals()和hashCode()。所以使用自定义对象时,应该对这两个方法进行重写
          */
     }
 
     public static void HastSetTest() {
         HashSet<Person> hs=new HashSet<Person>();
         //如果自定义对象也要达到确保唯一性的要求,就要覆写hashCode()和equals(),原因见上
         hs.add(new Person(11,"asd1"));
         hs.add(new Person(12,"asd2"));
         hs.add(new Person(13,"asd3"));
         hs.add(new Person(14,"asd4"));
         hs.add(new Person(11,"asd1"));
         for (Iterator<Person> i = hs.iterator(); i.hasNext();) {
             Person obj = (Person) i.next();
             System.out.println(obj.getName()+":"+obj.getAge());
         }
         //HashSet还有一个子类LinkedHashSet,具有LinkedList和HashSet双重特性:即有序又唯一
         LinkedHashSet<Person> lhs=new LinkedHashSet<Person>();
         lhs.add(new Person(11,"asd1"));
         lhs.add(new Person(12,"asd2"));
         lhs.add(new Person(13,"asd3"));
         lhs.add(new Person(14,"asd4"));
         lhs.add(new Person(11,"asd1"));
         for (Iterator<Person> i = lhs.iterator(); i.hasNext();) {
             Person obj = (Person) i.next();
             System.out.println(obj.getName()+":"+obj.getAge());
         }
     }
 
     public static void TreeSetDemo() {
         /*TreeSet集合会对存入的对象进行比较然后进行存放,比较的过程可以用以下两种方式实现
          * 1、使对象实现Comparable借口,重写compareTo(),称为自然排序方法
          * 2、使集合具备排序功能,就是向TreeSet中传入一个实现了Comparator接口的类的对象实例
          */
         TreeSet<Person> ts=new TreeSet<Person>();
         ts.add(new Person(21,"asd1"));
         ts.add(new Person(22,"asd2"));
         ts.add(new Person(22,"asd3"));
         ts.add(new Person(24,"asd4"));
         for (Iterator<Person> i = ts.iterator(); i.hasNext();) {
             Person p = (Person) i.next();
             System.out.println(p.getName()+":"+p.getAge());
         }
         TreeSet<Person> ts2=new TreeSet<Person>(new ComparatorByName());
         ts2.add(new Person(21,"asd1"));
         ts2.add(new Person(22,"asd2"));
         ts2.add(new Person(22,"asd3"));
         ts2.add(new Person(24,"asd1"));
         for (Iterator<Person> i = ts2.iterator(); i.hasNext();) {
             Person p = (Person) i.next();
             System.out.println(p.getName()+":"+p.getAge());
         }
     }
 }

SetSubDemo练习

 import java.util.Comparator;
 
 import com.lll.cn.Person;
 
 public class ComparatorByName implements Comparator<Person>
 {
     //这个类是外部类,用于集合中元素的比较
     @Override
     public int compare(Person p1, Person p2)
     {
         int comp=0;
 
         return (comp=p1.getName().compareTo(p2.getName()))!=0?comp:p1.getAge()-p2.getAge();
         //return 1;
     }
 }

TreeSet比较使用的类

哈希如何判断元素相等:

二叉树:会用自然排序或自定义排序方法进行排序,取出时按排好的顺序从左到右取出。但是并不意味着必须是从小到大的顺序,因为如果左边第一个是最大的,就是从大到小取。当然也可以有序存取(即先存先取/后存后取)

集合总结:

1、选择集合容器的技巧

2、集合容器体系和数据结构区分