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;

        

    }



}