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);
    }
}

下面是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;
    }
    
}

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();
    }
}

迭代器接口(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());
        }
    }
}

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;
    }
}

哈希如何判断元素相等:

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

集合总结:

1、选择集合容器的技巧

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