javaseday19补充(Collections 工具Utility 同步加锁原理 集合数组互转 可变参数 静态导入)

public class CollectionsDemo01 {
public static void main(String[] args) {
/*
* Collections是集合框架的工具类
* 里面的方法都是静态的
*
*/
demo_1();

}

private static void demo_4() {
List<String> list = new ArrayList<String>();


list.add("ssasda");
list.add("asa");
list.add("dasda");
list.add("lise");
list.add("zhangsan");
list.add("dse");
list.add("xiaohua");


// Collections.replaceAll(list, "basd", "bb"); //set(indexOf("aa"),"bb"); 2种方法合体
Collections.shuffle(list); //随机更换顺序  可以用于更换扑克牌顺序
// Collections.fill(list, "s");//都还原成某一个值
System.out.println(list);
}
private static void demo_3() {
/*TreeSet<String> ts = new TreeSet<String>(){
public int compare (String o1,String o2){
int temp =o2.compareTo(o1); //o1 和o2位置调换即可实现逆向


return temp;
}
};//自己实现倒过来排序的比较器
*/
//想逆序就reverse();
//Collections 把比较器放在 reverseOrder就可以实现比较后再逆向 reverseOrder自身带有比较器
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength01()));
ts.add("badd");
ts.add("aad");
ts.add("cad");
ts.add("ead");




System.out.println(ts);


}
private static void demo_2() {
List<String> list = new ArrayList<String>();


list.add("ssasda");
list.add("asa");
list.add("dasda");
list.add("vsasda");
list.add("basd");
// Collections.sort(list);
System.out.println(list);
System.out.println(Collections.max(list));//如果要找最长的可以加个长度比较器
System.out.println(Collections.binarySearch(list, "asa"));//插入点-1 保证为负 不-1的话可能是0角标


}

public static void demo_1(){
List<String> list = new ArrayList<String>();


list.add("ssasda");
list.add("asasda");
list.add("dasda");
list.add("vsasda");
list.add("basda");
System.out.println(list.size());
//对list集合进行指定顺序的排序
//
// Collections.sort(list);//下面是他的实现原理
mySort(list);
System.out.println(list);
}
//用到特定类型的方法 所以T extends Comparable 的子类具备比较性  为了提高扩展性 用? super T 让T的父类也能参与
public static <T extends Comparable <? super T>> void mySort(List<T> list){//?任意类型不一定带compareTo


for (int i = 0; i < list.size()-1; i++) {//?只能Object


for (int j = i+1; j < list.size(); j++) {


if(list.get(i).compareTo(list.get(j))>0){


// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);
}
}
}
}

}

通过自己创建比较器 进行长度比较

public static <T> void mySort(List<T> list,Comparator<? super T> comp){ //super T 让其父类也能参与比较

if(comp.compare(list.get(i),list.get(j))>0){

mySort(list,new ComparatorByLength01());

public class ComparatorByLength01 implements Comparator<String> {

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

/* List list = new ArrayList(); 非同步的
 *
 * list = MyCollections.synList(list);返回一个同步的list
 *
 * 就是Collections 中的 synchronizedList
 * 
 * 自己写就是复写他所有的方法 加上锁
 */
class MyCollection {
public List synList(List list){
return 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);
}
}


}
}

public class ArraysDemo01 {
public static void main(String[] args) {
/*
* Arrays 集合框架的工具类 里面的方法都是静态的
*
*/
// Arrays.toString(a);
// List<String> list = Arrays.asList(arr);//将数组转化成集合
// boolean b = list.contains("xixi");
// System.out.println(b);
demo_2();
}

//数组转集合
private static void demo_2() {
/*
* 如果数组中的元素是对象 那么转成集合时 直接将数组中的元素作为集合中的元素进行集合存储
*
* 如果数组中的元素是基本类型数值 那么会将该数组作为集合中的元素进行存储
*/
int[] arr= {22,1,35,4};


List<int[]> list = Arrays.asList(arr);//arr 是int数组 所以泛型中加int[]


System.out.println(list);
}
/*
* 重点 List asList (数组) 将数组转成集合
* 可以使用 集合的方法操作数组中的元素 不用自己写contains 之类的集合中的方法
* 注意 数组的长度是固定的 所以 对于集合的增删方法 是不可以使用的否则会发生UnsupportedOperationException
*
*/
public static boolean myContains(String[] arr,String str){
for (int i = 0; i < arr.length; i++) {
if(arr[i].equals(str)){
return true;
}
}
return false;
}
//toString的经典实现
public static String myString(long[] a) {
        if (a == null)
            return "null";
        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(", ");
        }
    }
}

/*
* 集合转成数组
* 使用的就是Collection接口中的 toArray方法
* 集合转成数组 可以对集合中的元素操作方法进行限定 不允许其进行增删
*
*
*/


List<String> list = new ArrayList<String>();
list.add("aa");
list.add("a2a");
list.add("a3a");
/*
* toArray 需要传入一个指定类型的数组
* 长度如何定义
* 如果长度小于集合的size 那么该方法会创建一个同类型并和集合同size的数组
* 如果长度大于集合的size 那么该方法就会使用指定的数组 存储集合中的元素 其他位置默认为null
* 所以简易 最后长度就指定集合的size 
*/
String[] arr = list.toArray(new String[100]);
System.out.println(Arrays.toString(arr));

/*
 * 1.5以后给Collection 找了个爹 Iterable 接口 其中就是迭代器的方法
 * 为了以后的集合都有迭代的功能 所以添加的新功能
 */
public class IteratorDemo01 {
/*
* foreach
* 格式
* for(类型 变量: Collection集合 |数组)
* {
*
* }
* 传统for 和高级for的区别
* 传统for 可以完成对语句执行很多次 因为可以定义控制循环的增量和条件
*
* 高级for是一种简化形式
* 它必须有被遍历的目标 该目标要使数组 要么是Collection单列集合
* 对于数组的遍历 如果仅仅是获取数组中的元素 可以使用高级for
* 如果要对数组的角标进行操作 建议使用传统for
*
*
*
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();


list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//1.5以后出现的 巨强 通常只用于遍历或迭代 不对元素过多的操作
for(String a: list){//简化书写
System.out.println(a);
}


int[] arr = {1,2,3,4};


for(int a:arr){ //传统for 可以定义 变量次数等等
System.out.println(a);
}
//可以使用高级for遍历map集合么？
//不能直接使用 但是可以将map转成单列的set就可以用了
Map<Integer,String> map = new HashMap<Integer,String>();


map.put(3, "zhangsan");
map.put(4, "wangcai");
map.put(35, "xiaohua");
map.put(1, "dabai");


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);
}
// Iterator<String> it = list.iterator();
//
// while(it.hasNext()){
// System.out.println(it.next());
// }
}
}

public class ParameterDemo01 {
public static void main(String[] args) {
// int sum = add(3,4);
// System.out.println(sum);
//
// int[] arr = {3,3,4,5,6};
// int sum2 = add(arr);
// System.out.println(sum2);
int sum = newAdd(5,21,1,2); //直接把数组的元素作为参数传递进函数
System.out.println(sum);
}
/*
* 函数的可变参数
* 其实就是一个数组 但是接受的是数组的元素
* 自动将这些元素封装成数组 简化了调用者的书写
* 
* 注意:可变参数类型 必须定义在参数列表的结尾处 只能有1个  简化的都有局限性
*/
public static int newAdd(int... arr){//...就代表省略 就数组 简化型的数组 可变参数
//可以传递n个int 类型的值 没有也创建个数组  将 创建数组的动作 内部完成  但是加上,就玩球 放在 可变参数前面 可以 因为先放进去了
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;


}


public static int add(int a,int b){
return a+b;
}
public static int add(int a,int b,int c){//重载
return a+b+c;
}


public static int add(int[] arr){//数据多就存起来 要先创建数组才能用
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
}

import java.util.ArrayList;
import java.util.Collections;
import static java.util.Collections.sort;//静态导入 其实导入的是类中的静态成员
import static java.lang.System.*;


public class StaticImportDemo01 {
public static void main(String[] args) {
//导包动作简化了书写 不然很麻烦 如下
java.util.List<String> list = new ArrayList<String>();

list.add("aab");
list.add("aab2");
list.add("aab3");
list.add("aab4");

sort(list);//静态成员导入后直接sort就行  如果冲突了类名不能少
out.println(11);//out 是静态的但是后面的不是静态 System可以省略 out不能省了
Collections.max(list);
}
}