字符串、数组、集合和Map

String 和StringBuffer

//s1两次输出的哈希值是不同的，sb1两次输出的哈希值是相同的，解释了String是不可变的，重新赋值相当于指向另一个内存空间。

String s1 = "Hello";

System.out.println(s1.hashCode());

s1 = s1 + "world";

System.out.println(s1.hashCode());

StringBuffer sb1 = new StringBuffer("Hello");

System.out.println(sb1.hashCode());

sb1 = sb1.append("world");

System.out.println(sb1.hashCode());

字符串逆序reverse函数是StringBuffer类特有的方法，String类没有该方法，该方法会改变自身。

//如下所示

StringBuffer sb1 = new String("Helloworld");

System.out.println(sb1.reverse());//输出 dlrowolleH

System.out.println(sb1);// 输出 dlrowolleH

*String、StringBuffer、StringBuilder异同：都是处理字符串的类，String是不可变的，后面两个是可变的，StringBuffer是线程安全的。若不涉及线程安全问题，建议使用StringBuilder。StringBuffer和StringBuilder初始化时会默认有初始容量16，若超出该值，则会分配新的内存缓冲区。

数组的clone方法

//数组的clone方法复制的是栈中的内容，直接赋值是赋值堆中的内容，c和a是无关的，修改a中的元素不会影响c。 a==b是true, a==c是false

int[] a = {1,2,3};

int[] b;

int[] c;

b = a;

c = a.clone();

a[0] = 0;

数组的工具类Arrays： asList方法、二分查找、复制指定长度的数组、比较数组是否相等、排序、自定义规则排序、转字符串等。

//asList方法大概用法是这样，目前还不清楚这个方法具体的作用

char[] chs1 = "jack".toCharArray();

char[] chs2 = "lucy".toCharArray();

char[] chs3 = "marry".toCharArray();

List<char[]> list = Arrays.asList(chs1,chs2,chs3);

//排序和自定义排序，数组工具类中只有基本类型的升序排序方法sort，若想实现降序或者自定义的排序方式，需要自己定义一个比较器，并实现排序规则

Integer[] arr = {5,2,4,9,1,6,3,7,8};

Arrays.sort(arr);//arr会被默认按照升序排列

printArr(arr);//输出1,2,3,4,5,6,7,8,9

//自定义的一个比较器，按照降序进行排序

Arrays.sort(arr, new Comparator<Integer>()

{

    public int compare(Integer o1, Integer o2)

    {

        return o1 > o2 ? -1 : 1;

    }

});

printArr(arr);//输出9,8,7,6,5,4,3,2,1

//学生按名字或成绩排序问题，用Arrays类提供的排序方法，自定义一个比较器

//定义好一个学生类，有姓名、中文成绩、数学成绩、英文成绩、总成绩这几个字段，学生类自身没有实现自然排序的接口

Student stu1 = new Student("aa", 90, 68, 85);

Student stu2 = new Student("bb", 88, 98, 95);

Student stu3 = new Student("ab", 74, 95, 90);

Student stu4 = new Student("aab", 84, 85, 70);

Student stu5 = new Student("ac", 84, 85, 70);

Student stu6 = new Student("aa", 84, 85, 70);

Student[] studentArr = {stu1, stu2, stu3, stu4, stu5, stu6};

Arrays.sort(studentArr, new Comparator<Student>()

{

    public int compare(Student o1, Student o2)

    {

//                return o1.getC_score() > o2.getC_score() ? 1 : -1;     //按中文成绩升序排序

//                return o1.getM_score() > o2.getM_score() ? -1 : 1;     //按数学成绩降序排序

//                return o1.getE_score() > o2.getE_score() ? 1 : -1;     //按英文成绩升序排序

//                return o1.getSumScore() > o2.getSumScore() ? -1 : 1;     //按总成绩降序排序

//按名字升序排序

        char[] chs1 = o1.getName().toCharArray();

        char[] chs2 = o2.getName().toCharArray();

        int minLength = chs1.length > chs2.length ? chs2.length : chs1.length;

        for(int i=0;i < minLength;)

        {

            if(chs1[i] == chs2[i])

            {

                i++;

            }

            else

            {

                return chs1[i] > chs2[i] ? 1 : -1;

            }

        }

        return chs1.length > chs2.length ? 1 : -1;

    }

});

System.out.println("name"+"\t"+"c_score"+"\t"+"m_score"+"\t"+"e_score"+"\t"+"sumScore");

printStuInfo(studentArr);

//还有另一种排序方式，以Teacher类为例，让Teacher类实现comparable接口，该接口中只有一个compareTo(T o)方法

public class Teacher implements Comparable<Teacher>

{

    private String name;

    private int age;    

    public Teacher(String name, int age)

    {

        this.name = name;

        this.age = age;

    }

    public String getName()

    {

        return name;

    }

    public int getAge()

    {

        return age;

    }

    public int compareTo(Teacher o)

    {

        return this.getAge() > o.getAge() ? 1 : -1;

    }    

}

*对象的排序有两种方式：一种是让该类实现comparable接口，实现里面的compareTo(o)方法，排序时直接使用Arrays.sort(objArr)即可；另一种是调用Arrays.sort(objArr, Comparator)方法的时候，创建一个内部的比较器对象并实现里面的compare(o1, o2)方法即可。

集合(包括队列、双端队列、栈等都属于集合的内容)

集合（Collection是一个超级接口，底下还有很多子接口如List、Set、SortedSet、Queue、Deque等），遍历集合时，移除元素时应该使用迭代器进行元素的移除。若直接用集合移除，可能会出现意料之外的结果。

    |--List（有序有重复）

        |--ArrayList（底层是数组，线程不安全）

        |--Vector（底层是数组，线程安全）

            |--Stack

        |--LinkedList（底层是链表）

    |--Set（无序无重复）

        |--HashSet

            |--LinkedHashSet(保证存入顺序的set集合)

        |--TreeSet（实现SortedSet接口，可自定义比较器，若不定义比较器则默认按自然顺序进行排序）

//如下面示例所示

ArrayList<String > arrlist = new ArrayList<String>();

LinkedList<String> linklist = new LinkedList<String>();

linklist.add("aaa");

linklist.add("bbb");

linklist.add("ccc");

linklist.addFirst("0000");

linklist.addLast("9999");        

arrlist.add("ddd");arrlist.add("eee");arrlist.add("fff");

linklist.addAll(4, arrlist);        

HashSet<String> hashSet = new HashSet<String>(linklist);

LinkedHashSet<String> lhashSet = new LinkedHashSet<String>(linklist);

for(String s : hashSet)

{

    System.out.print(s);

}

System.out.println("\n--------------------------");

for(String s : lhashSet)

{

    System.out.print(s);

}        

TreeSet<String> tset = new TreeSet<String>(linklist);

System.out.println("\n--------------------------");

for(String s : tset)

{

    System.out.print(s);

}

输出：

aaacccbbbeeeddd0000fff9999  //hashset的顺序和存入的顺序无关，不能保证输出时顺序就是存入时的顺序

--------------------------

0000aaabbbcccdddeeefff9999   //lhashset的顺序和存入的顺序相同，输出就是存入时元素的顺序

--------------------------

00009999aaabbbcccdddeeefff   //tset在没有指定比较器的情况下，默认按照自然顺序对存入的元素进行排列

若TreeSet存放的是学生或者老师对象，则他们必须实现comparable接口，实现自然排序的方法，否则即使程序编译没有错误，程序运行的时候也会报错。

Map（ 此接口取代 Dictionary 类，如HashTable就继承 Dictionary类 并实现了Map接口 ）

    |--HashTable(键值均需为非null，同步的)

    |--HashMap(允许null值和null键，非同步的)

         |--LinkedHashMap（ 保证存入顺序的set集合 ）

    |--TreeMap（实现SortedMap接口， 可自定义比较器，若不定义比较器则默认按自然顺序进行排序 ）

1、entrySet方式

     Set<Entry<String, String>> entrySet = numberMap .entrySet();

   for (Entry<String, String> e : entrySet)

  {

     System. out .println(e.getKey() + "\t" + e.getValue());

  }

2、keySet方式

     Set<String> keySet = numberMap .keySet();

   for (String key : keySet)

  {

      System. out .println(key + "\t"  + numberMap .get(key));

  }

Collections工具类：二分搜素获取指定元素、判断两个集合有没有交集、获取最大最小元素（包括自定义比较器）、反转、打乱顺序、排序，和 保证集合或者Map实现同步（ 集合工具类的Collections.synchronizedXxx()方法可以 ）。