JAVA基础学习之String、StringBuffer、StringBuilder、基本数据类型的使用、整形进制转换、集合Collection、Vector、ArrayList、LinkedList、HashSet、TreeSet等（3）

主函数类MainDemo.java

package com.itcast.test20140109;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.TreeSet;
import java.util.Vector;

public class MainDemo {

    public static void main(String[] args) {
        // StringUserMethod();
        // StringBufferUserMethod();
        /*
         * StringBuffer是线程同步的，通常用于多线程
         * StringBuilder是线程不同步的，多线程不安全，通常用于单线程，JDK1.5以后出现，提高效率
         */
        
        /*
         * 基本数据类型对象包装类
         * 为了方便操作基本类型值，将其封装成了对象
         * 用于描述该对象的类就称为基本数据类型对象包装类
         * byte Byte
         * short Short
         * int Integer
         * long Long
         * float Float
         * double Double
         * char Character
         * boolean Boolean
         */
        
        //进制转换
        //ConvertJinzhi();
        
        //关于Collection的使用
        CollectionUser();
        
    }
    
    
    /**
     * 关于Collection的使用
     */
    public static void CollectionUser() {
        /*
         * Collection的常见方法：
         * boolean isEmpty();判断集合中是否有元素
         * int size()
         * Iterator iterator();取出元素的方式，迭代器
         * Iterator接口就是对所有的Collection容器进行元素取出的公共接口
         * boolean retainAll(Collection coll):取交集
         * 
         */
        Collection collection = new ArrayList();
        collection.add("aa1");
        collection.add("aa2");
        collection.add("aa3");
        //使用集合后不需要使用迭代器，使用for，若还需要使用，就使用while
        for (Iterator iterator = collection.iterator();iterator.hasNext();) {
            System.out.println(iterator.next());
        }
        
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
        /*
         * List:有序（存入和取出的顺序一致），元素都有索引，元素可以重复
         * Set：元素不能重复，无序。
         * Object set(index,element);修改List集合中的元素
         * Object get(index);获取List集合中的元素
         * List subList(from,to);获取List集合中的子集合元素
         */
        
        //使用ListIterator操作List集合
        List list = new ArrayList();
        list.add("1");
        list.add("2");
        list.add("3");
        ListIterator it = list.listIterator();//使用listIterator可以修改list集合中的元素，不会抛出异常
        while(it.hasNext()){
            Object object = it.next();
            if(object.equals("2")){
                it.add("4");//要添加到迭代器中，不能list.add("4");
            }
            System.out.println(object);
        }
        System.out.println(list);
        
        /*
         *Vector:内部是数组数据结构，是同步的。正删查都很慢
         *ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
         *LinkedList:内部是数组数据结构。是不同步的。增删元素的速度很快 
         */
        Vector vector = new Vector();
        vector.addElement("a1");
        vector.addElement("a2");
        /*
         * 下面这种写法不推荐使用，应该使用Iterator
         */
        Enumeration enumeration = vector.elements();
        while (enumeration.hasMoreElements()) {
            System.out.println(enumeration.nextElement());
        }
        
        LinkedList linkedList  = new LinkedList();
        linkedList.addFirst("linkedList1");
        linkedList.addFirst("linkedList2");
        System.out.println(linkedList.getFirst());//获取第一个但不删除
        System.out.println(linkedList.removeFirst());//返回删除的这个元素
        
        /*
         * HashSet集合数据结构是哈希表，所以存储元素的时候，使用元素的hashCode方法来确定元素的位置，
         * 再通过元素的equals方法来确定是否相同,如果存储自定义对象，可以重写hashCode方法和equals方法
         * LinkedHashSet 有序的存储方式，HashSet hashSet = new LinkedHashSet();
         * TreeSet：可以对TreeSet集合中元素进行排序，是不同步的,会调用compareTo（）进行比较排序，
         * 如果自定义类型排序，
         * 1.需要实现Comparable接口，重写compareTo（）方法
         * 2.定义一个类实现Comparator接口，覆盖compare方法，将该类对象作为参数传递给TreeSet集合的
         * 构造函数，推荐使用这种TreeSet treeSet = new TreeSet(new ImplementComparator());
         * 比如字符串长度比较
         */
        TreeSet treeSet = new TreeSet(new CompareByStringLength());
        treeSet.add("bb");
        treeSet.add("aaa");
        for (Object object : treeSet) {
            String string = object.toString();
            System.out.println(string);
        }
        
    }



    /*
     * 进制转换
     */
    public static void ConvertJinzhi() {
        /*整数具备不同的进制体现
         * 十进制转换其他进制
         */
        System.out.println(Integer.toBinaryString(60));//转换二进制
        System.out.println(Integer.toOctalString(60));//转换八进制
        System.out.println(Integer.toHexString(60));//转换十六进制
        /*
         * 其他进制转换十进制
         */
        System.out.println(Integer.parseInt("111100",2));//二进制转换十进制 
        System.out.println(Integer.parseInt("74",8));//八进制转换十进制 
        System.out.println(Integer.parseInt("3c",16));//十六进制转换十进制 
    }

    /*
     * StringBuffer 使用
     */
    public static void StringBufferUserMethod() {
        /*
         * StringBuffer：就是字符串缓冲区 用于存储数据的容器。 特点： 1.长度是可变的 2.可以存储不同类型数据。
         * 3.最终要转车字符串进行使用。 4.可以对字符串进行修改。
         * 
         * StringBuffer append(data); StringBuffer insert(index,date);
         * StringBuffer delete(start,end); StringBuffer deleteCharAt(int
         * index);//删除指定位置的元素 char charAt(index) int indexOf(string) int
         * lastIndexOf(string); StringBuffer replace(start,end,String);
         */
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(true).append("1");
        System.out.println(stringBuffer.toString());// true1
        stringBuffer.insert(1, "a");
        System.out.println(stringBuffer.toString());// tarue1
    }

    /*
     * String类使用
     */
    public static void StringUserMethod() {
        String s1 = "abcd";// 创建一个字符串在常量池中
        String s2 = new String("abcd");// 创建两个对象，一个new，一个字符串对象在堆内存中
        System.out.println(s1 == s2);// false
        System.err.println(s1.equals(s2));// true，比较内容

        System.out.println(s1.length());// 4
        System.out.println(s1.charAt(2));// c
        System.out.println(s1.indexOf('c'));// 2，找不到返回-1
        System.out.println(s1.lastIndexOf('d'));// 3,lastIndexOf根据字符串获取在字符串中的第一次出现的位置
        System.out.println(s1.substring(0, 1));// a

        /*
         * String [] split(String regex); char[] toCharArray(); byte[]
         * getBytes(); String toUpperCase(); String toLowerCase(); String
         * replace(char oldch,char newch) String replace(String s1,String s2);
         * String trim(); String concat(string);//将字符串进行连接
         */

        /*
         * boolean equals(Object obj) boolean equalsIgnoreCase(String str)
         * boolean startsWith(String str) boolean endsWith(String str)
         */
        System.out.println("a".compareTo("b"));// -1,a<b
    }
}

字符串长度比较器CompareByStringLength.java

package com.itcast.test20140109;

import java.util.Comparator;

/**
 * 字符串长度比较器
 * @author yxl
 *
 */
public class CompareByStringLength implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        String s1 = (String)o1;
        String s2 = (String)o2;
        int temp = s1.length()-s2.length();
        return temp==0?s1.compareTo(s2):temp;
        
    }

}