JAVA笔记1

• 排序操作
• 查找，替换操作
• 同步控制
• Comparator定制排序
• • java.lang.Comparable 接口自然排序(内里面)
  • java.util.Comparator定制排序(类外)

1. 各种排序
2. 替换、查找
3. 同步控制(但是一般不使用，效率太低，Java的JUC包下的集合更适合并发操作、线程安全)

void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面

int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target)
boolean replaceAll(List list, Object oldVal, Object newVal)//用新元素替换旧元素

现在的同步控制一般采用synchronized()方法，Java的高并发与同步控制是一个很值得说的东西，需要不断深入学习，同步控制主要是为了解决线程不安全的问题，有必要总结一下Java里哪些是线程安全的：

• 线程安全：HashTable、Vector
• 线程不安全：HashSet，TreeSet，ArrayList,linkedList,HashMap,TreeMap

记住很少的线程安全的，剩下的就是不安全的，一些方法如下(一般都用JUC包下的集合来处理并发，效率高)：

synchronizedCollection(Collection  c) //返回指定 collection 支持的同步（线程安全的）collection。
synchronizedList(List list)//返回指定列表支持的同步（线程安全的）List。
synchronizedMap(Map m) //返回由指定映射支持的同步（线程安全的）Map。
synchronizedSet(Set s) //返回指定 set 支持的同步（线程安全的）set。

值得一提的是，我们排序可能往往按照自己定制的方法排序，比如按照学生的年龄进行排序。这个时候其实有两种思路可供选择：

• 一种是在类里面写，类实现了java.lang.Comparable接口，重写**compareTo()**的规则，外面调用排序什么的时候就会使用这个规则
• 另一种在类外面，也叫定制排序，可以再调用sort排序方法时重写java.util.Comparator方法

public class Person implements Comparable {
    private Integer age;
 
    public Person(Integer age) {
        this.age = age;
    }
 
    @Override
    public int compareTo(Person person) {
        return this.age - person.age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

@Test
public void test1() {
    Person[] peoples = new Person[4];
    peoples[0] = new Person(11);
    peoples[1] = new Person(19);
    peoples[2] = new Person(18);
    peoples[3] = new Person(10);
 
    Arrays.sort(peoples);
 
    System.out.println(Arrays.toString(peoples));
}

output：

public class Person {
    private Integer age;
 
    public Person(Integer age) {
        this.age = age;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

@Test
public void test2() {
    Person[] peoples = new Person[4];
    peoples[0] = new Person( 13);
    peoples[1] = new Person(19);
    peoples[2] = new Person(17);
    peoples[3] = new Person(16);
 
    Arrays.sort(peoples, new Comparator() {
        @Override
        public int compare(Person person1, Person person2) {
            return person1.getAge() - person2.getAge();
        }
    });
 
    System.out.println(Arrays.toString(peoples));
}

output: