Collections、Arrays:是集合框架的工具类，里面的方法都是静态的。
比较器：
public class ComparatorByLength implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
int temp=o1.length()-o2.length();
return temp==0?o1.compareTo(o2):temp;
}
}
CollectionsDemo:
public static void main(String[] args) {
/*
Collections:是集合框架的工具类。
里面的方法都是静态的。
*/
demo_1();
demo_2();
demo_3();
demo_4();
}
private static void demo_4() {
List<String> list=new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");
System.out.println(list);
// Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");//替换
Collections.shuffle(list);//随机把元素安放在集合的位置上
// Collections.fill(list, "cc");//全部替换成cc
System.out.println(list);
}
private static void demo_3() {
/*逆序
TreeSet<String> ts=new TreeSet<String>(new Comparator<String>(){
@Override
public int compare(String o1, String o2) {
int temp=o2.compareTo(o1);
return temp;
}
});*/
TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));//逆序比较器再调用
ts.add("abc");
ts.add("hahaha");
ts.add("zzz");
ts.add("aa");
ts.add("cba");
System.out.println(ts);
}
private static void demo_2() {
List<String> list=new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
int index=Collections.binarySearch(list, "cba");
System.out.println("index="+index);
// 获取最大值
String max=Collections.max(list,new ComparatorByLength());
System.out.println("max="+max);
}
private static void demo_1() {
List<String> list=new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
// 对list集合进行指定顺序的排序
// Collections.sort(list);
// mySort(list);
mySort(list,new ComparatorByLength());
}
//Collections中sort方法的原理
private static<T extends Comparable<? super T>> void mySort(List<T> list,Comparator<? super T> comp) {
for(int i=0;i<list.size();i++){
for(int j=i+1;j<list.size();j++){
//if(list.get(i).compareTo(list.get(j))>0)
if(comp.compare(list.get(i),list.get(j))>0){
/*
T temp=list.get(i);
list.set(i, list.get(j));
list.set(j, temp);
*/
Collections.swap(list, i, j);
}
}
}
}
如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
如果数组中的元素是基本类型数值，那么将该数组作为集合中的元素进行存储。
ArrayDemo:
//数组转集合
public static void main(String[] args) {
/*
Arrays:集合框架的工具类。
里面的方法都是静态的。
*/
int[] arr={3,1,5,6,3,6};
System.out.println(Arrays.toString(arr));
demo_2();
}
private static void demo_2() {
/*
如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
如果数组中的元素是基本类型数值，那么将该数组作为集合中的元素进行存储。
*/
int[] arr={31,11,51,61};
List<int[]> list=Arrays.asList(arr);
System.out.println(list.size());
}
private static void demo_1() {
/*
重点：List asList(数组)将数组转成集合。
好处：其实可以使用集合的方法操作数组中的元素。
注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的
否则会发生UnsupportedOperationException
*/
String[] arr={"abc","haha","xixi"};
boolean b=myContains(arr,"xixi");
System.out.println("contains:"+b);
List<String> list=Arrays.asList(arr);
boolean b1=list.contains("xixi");
System.out.println("list contain:"+b1);
// list.add("hiahia");UnsupportedOperationException
System.out.println(list);
}
private static boolean myContains(String[] arr, String key) {
for(int i=0;i<arr.length;i++){
if(arr[i].equals(key))
return true;
}
return false;
}
//toString的经典实现，Api里的实现方法
public static String myToString(int[] a){
int iMax=a.length-1;
if(iMax==-1)
return "[]";
StringBuilder b=new StringBuilder();
b.append('[');
for(int i=0;;i++){//中间省了条件判断，提高了效率
b.append(a[i]);
if(i==iMax)
return b.append(']').toString();
b.append(",");
}
}
集合转成数组：使用的是Collections接口中的toArray()
集合转成数组：可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
ToArray:
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
/*
toArray方法需要传入一个指定类型的数组。
长度该如何定义？
如果长度小于集合的size，那么该方法创建一个同类型并和集合相同size的数组。
如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null。
所以建议，最好长度就指定为集合的size。
*/
String[] arr=list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));
}
1.5特性：
foreach语句：
格式：
for(类型 变量 ：Collection集合|数组){}
传统for和高级for的区别？
传统for可以完成对语句执行很多次，因为可以定义控制循环的变量和条件。
高级for是一种简化形式。它必须有被遍历的目标。该目标要么是数组，要么是Collection单列集合。
对数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。如果要对数组的角标进行操作建议使用传统for。
Foreach：
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
for(String s:list){//简化书写
System.out.println(s);
}
int[] arr={3,1,5,7,4};
for(int i:arr){
System.out.println(i);
}
// 可以使用高级for遍历map集合吗？不能直接用，但是可以将map转成单列的set，就可以用了
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(3,"zhagsan");
map.put(1,"wangyi");
map.put(7,"wagnwu");
map.put(4,"zhagsansan");
for(Integer key:map.keySet()){
String value=map.get(key);
System.out.println(key+": :"+value);
}
for(Map.Entry<Integer, String> me:map.entrySet()){
Integer key=me.getKey();
String value=me.getValue();
System.out.println(key+":"+value);
}
}
函数的可变参数。其实就是一个数组，但是接收的是数组的元素。自动将这些元素封装成数组。简化了调用者的书写。
注意：可变参数类型，必须定义在参数列表的结尾。
ParamterDemo:
public static void main(String[] args) {
int sum=add(4,5);
System.out.println("sum="+sum);
int sum1=add(4,5,6);
System.out.println("sum1="+sum1);
int[] arr={5,1,4,7,3};
int sum3=add(arr);
System.out.println("sum3="+sum3);
int[] arr1={5,9,1,4,7,3,9,8,7,6};
int sum4=add(arr1);
System.out.println("sum4="+sum4);
int sum5=newAdd(5,1,4,7,3);
System.out.println("sum5="+sum5);
int sum6=newAdd(5,9,1,2,7,3,9,8,7,6);
System.out.println("sum6="+sum6);
}
/*
函数的可变参数。
其实就是一个数组，但是接收的是数组的元素。
自动将这些元素封装成数组。简化了调用者的书写。
注意：可变参数类型，必须定义在参数列表的结尾。
*/
private static int newAdd(int b,int... a) {
int sum=0;
for(int i=0;i<a.length;i++){
sum+=a[i];
}
return sum;
}
private static int add(int[] arr) {
int sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
return sum;
}
private static int add(int i, int j, int k) {
return i+j+k;
}
private static int add(int i, int j) {
return i+j;
}
java Api提供的静态方法可以用import导入
StaticImportDemo：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.*;//静态导入，其实到入的是类中的静态成员。
//import static java.util.Collections.max;//静态导入，其实到入的是类中的静态成员。
import static java.lang.System.*;
public class StaticImportDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc3");
list.add("abc7");
list.add("abc1");
out.println(list);
sort(list);
System.out.println(list);
String max=max(list);
out.println(max);
}
}
List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list.
给非同步的集合加锁的原理：
class MyCollections{
public static List synList(List list){
return new MyList(list);
}
private class MyList implements List{
private List list;
private static final Object lock = new Object();
MyList(List list){
this.list = list;
}
public boolean add(Object obj){
synchronized(lock)
{
return list.add(obj);
}
}
public boolean remove(Object obj){
synchronized(lock)
{
return list.remove(obj);
}
}
}
}
