目录 :
23). 集合(Coolections-sort)
二十三. 集合(Collections -sort) -->集合框架工具类
23). 集合(Coolections-sort)
24 ).
集合(Collection
s-max
)
25 ).
集合(Collection
s-binarySearch
)
26 ).
集合(Collection
s-替换反转
)
27 ).
集合(Collection
s-reverseOrder
)
28 ).
集合(Collection
s-Synlist
)
29 ).
集合(Arrays
)
30 ).
集合(集合转成数组
)
31 ).
集合(增强for循环
)
32 ).
集合(可变参数
)
33 ).
集合(静态导入
)
二十三. 集合(Collections -sort) -->集合框架工具类
1 ) . Collection与Conllections有什么区别?
1.1 Conllections 此类仅由静态方法组合或返回集合-->它包含对集合进行操作的多态算法,"包装器"返回由指定集合支持的新集合,以及其他一些可能的和最终的
[1] 方法都静态
[2]没有构造函数,无需创建对象
[3] 它是对集合进行操作的工具类
2 ) .sort(List<T> list ,Comparator<? super T> c ) 方法
2.1 sort方法的泛型限定解说 --> List<T> list : 指 传入List集合,类型不确定,用<T>标识 ; Comparator<? super T> c : 指继承comparator的类本身,或类的子集 ,指上限
3 ) . Demo :
import java.util.*;/*集合框架的工具类 : Collections*///自定义比较器class strLengthComparator implements Comparator<String>{public int compare(String s1,String s2){if(s1.length()>s2.length())return 1;if(s1.length()<s2.length())return -1;return s1.compareTo(s2);}}class CollectionSort{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){ArrayList<String> array = new ArrayList<String>();array.add("summe");array.add("wint");array.add("springss");array.add("sp");array.add("autumn");getSort(array);//默认按字母排序Collections.sort(array);getSort(array);//按自定义的字母的数量排序Collections.sort(array, new strLengthComparator());getSort(array);}public static void getSort(ArrayList ary){sop(ary);}}
小结 :
1. 若某类继承Comparable则说明该类具有比较性2. 当内置方法排序满足不了需求是,可自定义比较器
3 . comparable接口中需要覆盖的是compareTo,一般用在类上 --> compartor接口中需要覆盖的是compare,一般用在比较器上
二十四
. 集合(collection-max)
1 ) . Demo :
import java.util.*;/*集合框架的工具类 : CollectionsMax: -->求最大值*/class CollectionMax{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){getMax();}public static void getMax(){ArrayList<String> arry = new ArrayList<String>();arry.add("summer");arry.add("winter1");arry.add("spring");arry.add("autumn");Collections.sort(arry);sop(arry);//默认输出默认排序的最后一位String max = Collections.max(arry);//输出自定义字符串长度排序后的最后一位String max = Collections.max(arry,new strLengthComparter());sop(max);}}//比较器class strLengthComparter implements Comparator<String>{public int compare(String s1,String s2){if(s1.length()>s2.length())return 1;if(s1.length()<s2.length())return -1;return s1.compareTo(s2);}}
2 ) . max --> 默认求出默认排序的最后一位,也就是最大值 ; 可通过自定义比较器去更改比较方式
二十五
. 集合(collections-binarySearch)
1 ) . binarySearch --> 使用二分法搜索指定列表,以获得对象
2 ) . Collection.binarySearch 是用来通过二分查找指定列表,获取元素的指定对象的坐标的--> 使用以及原理
import java.util.*;/*该节内容讲述了 : Collection.binarySearch 是用来通过二分查找指定列表,获取元素的指定对象的坐标的1.binarySearch的用法2.binarySearch的原理 -->二分查找3.外置比较器的使用*/class CollectionBinarySearch{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){List<String> li = new ArrayList<String>();li.add("summer");li.add("autumn");li.add("spring");li.add("winter");//默认排序Collections.sort(li);sop(li);//使用二分法查找summer所在位置的角标int key = Collections.binarySearch(li,"123");// sop("index:"+key);int key1 = haleSearch(li,"spring12");sop(key1);}//二分查找的原理-->当元素具有比较性时public static int haleSearch(List<String> list,String key){ //定义变量int max,min,mid;//最大值坐标max=list.size()-1;//最小值坐标min=0;while(min<=max){ //不断的将角标顶到中间值位置mid = (max+min)>>1;//获取角标中间值上的数值String str = list.get(mid);//将中间值与传入的值相比较,若相等则返回其坐标.若不等返回-1int num = str.compareTo(key);//大于零说明有这个值,那么直接折半 ,折半的方式就是 max=mid-1; -->这个是从大到小if(num>0)max=mid-1;//小于零则说明没有这个值,那么也直接折半,折半方式就是min=mid+1; -->这个是从小到大else if(num<0)min=mid+1;elsereturn mid ;//查找到后返回确定的值}return -min-1; //查询了一圈都没找到,就直接返回其应该插入的位置的-角标-1}//二分查找的原理-->当元素不具有比较性时,使用外部比较器public static int haleSearch(List<String> list,String key,Comparator<String> cmp){ //定义变量int max,min,mid;//最大值坐标max=list.size()-1;//最小值坐标min=0;while(min<=max){ //不断的将角标顶到中间值位置mid = (max+min)>>1;//获取角标中间值上的数值String str = list.get(mid);//将中间值与传入的值相比较,若整数则str>key,若负数则str<keyint num = cmp.compare(str,key);//大于零说明有这个值,那么直接折半 ,折半的方式就是 max=mid-1; -->这个是从大到小if(num>0)max=mid-1;//小于零则说明没有这个值,那么也直接折半,折半方式就是min=mid+1; -->这个是从小到大else if(num<0)min=mid+1;elsereturn mid ;//查找到后返回确定的值}return -min-1; //查询了一圈都没找到,就直接返回其应该插入的位置的-角标-1}}
小结 :
1. 折半插入排序原理图
二十六. 集合(collections-替换反转)
1 ) . 该节讲述了 collections中的填充,替换,反转这三个方法的使用
2 ) . Demo:
import java.util.*;/*该节内容讲述了 : Collection.fill 是填充一个列表 ; Collection.replaceAll 是替换列表中的元素 Collection.reverse 是反转列表*/class CollectionReversal{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){//fillDemo(); //填充方法//replaceDemo(); //替换方法//reverseDemo(); //反转方法}public static void fillDemo(){List<String> li =new ArrayList<String>();li.add("summer");li.add("autumn");li.add("spring");li.add("winter");sop("原始列表 : " +li);//Collections中的fill方法可将list列表中的所有元素替换成一个别的元素Collections.fill(li,"season");sop("填充列表 : " +li);}public static void replaceDemo(){List<String> li =new ArrayList<String>();li.add("summer");li.add("autumn");li.add("spring");li.add("winter");sop("原始列表 : " +li);//Collections中的replaceAll方法可将list列表中的指定单个元素替换成一个别的元素Collections.replaceAll(li,"summer","season");sop("替换列表 : " +li);}public static void reverseDemo(){List<String> li =new ArrayList<String>();li.add("summer");li.add("autumn");li.add("spring");li.add("winter");sop("原始列表 : " +li);//Collections中的replaceAll方法可将list列表中的指定单个元素替换成一个别的元素Collections.reverse(li);sop("反转列表 : " +li);}}
二十七
. 集合(collection-reverseOrder)
1 ) . collection-reverseOrder -->反转列表中的元素,或反转比较器中的元素
2 ) . Demo :
import java.util.*;/*该节内容讲述了 : Collections.reverseOrder() --> 可以用来反转列表中的元素,也可用来反转比较器中的元素得到 : 有序的list 采用sop输出; 无序的set 尽量采用迭代器输出*///外置比较器 : 按照原始的字母排序class StrComparator implements Comparator<String>{public int compare(String s1,String s2){return s2.compareTo(s1);}}//外之比较器 : 按照字母的长短排序class StrLengthCompartor implements Comparator<String>{public int compare (String s1,String s2){if(s1.length()>s2.length())return -1;else if(s1.length()<s2.length())return 1;elsereturn s1.compareTo(s2);}}class CollectionReversalOrder{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){//原始的通过外置比较器长度排序TreeSet<String> li = new TreeSet<String>(new StrLengthCompartor());//原始的通过外置比较器字母默认排序// TreeSet<String> li = new TreeSet<String>(new StrComparator());//通过工具类中的方法Collections.reverseOrder() --> 反转列表中的元素// TreeSet<String> li = new TreeSet<String>(Collections.reverseOrder());//通过工具类中的方法Collections.reverseOrder() -->反转外置比较器中长度排序中比较的元素// TreeSet<String> li = new TreeSet<String>(Collections.reverseOeder(new StrLengthCompartor()));li.add("summer");li.add("su");li.add("sum");li.add("summe");//迭代输出/* for(Iterator<String> it= li.iterator(); it.hasNext();){String str = it.next();sop(str);} */}}
二十八
. 集合(Collections-Synlist)
1 ) . collections-Synlist 的底层是 通过同步代码块上加同一个锁来实现让添加,修改,删除等操作同一时间只能一个操作,以此实现同步
2 ) . demo :
import java.util.*;/*该节内容讲述了 :方法一 : Collections. Syn...list/map/collection可以让非同步的方法变成同步的方法方法二 : reverse是反转,而此方法的底层调用的是swap ,swap是置换方法三 : Collections.shuffle(list); -->此方法可将集合中的元素随机排放 -->案例 : 扑克牌 , 筛子底层重点:collections-Synlist 的底层是 通过同步代码块上加同一个锁来实现让添加,修改,删除等操作同一时间只能一个操作,以此实现同步*/class CollectionSynlist{public static void sop(Object obj){System.out.println(obj);}public static void shuffleDemo(){List<String> li =new ArrayList<String>();li.add("summer");li.add("autumn");li.add("winter");li.add("spring");sop(li);Collections.shuffle(li);sop(li);}//主方法public static void main(String args[]){List<String> li =new ArrayList<String>();li.add("summer");li.add("autumn");li.add("winter");li.add("spring");// sop(li);//交换集合中角标1与角标2的元素Collections.swap(li,1,2);// sop(li);//元素随机集合shuffleDemo();}}小结 :
1. 集合中非常多的对象的共同特点是 线程不安全
二十九
. 集合(Arrays)
1 ) . Arrays : 指用来操作数组的封装类, 内含操数组静态方法
2 ) . Demo
import java.util.*;/*该节内容讲述了 :Arrays : 用于操作数组的工具类 ,内都是静态方法collections : 用于操作集合的工具类,内都是静态方法Arrays.toString(数组) -->将数组变成字符串Arrays.asList(数组)-->将数组变成List集合list.contains(元素)-->判断list集合内是否含有该元素*/class CollectionArrays{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){int[] in = {1,2,3};Integer[] ing = {2,3,4};String[] str ={"sum","atr","asd"};//数组变字符串sop(Arrays.toString(in));/*把数组变成集合的好处?1.可以使用集合的思想和方法来操作数组,例如contains方法,get(),indexOf(),subList()等ps: 数组可以变集合,但不可使用集合中的增加,删除方法,因为数组的长度固定,若使用则会报UnsupportedOperationException不支持操作异常*///把数组变成集合/* List<String> str1 = Arrays.asList(str);str1.add("1223");//判断集合中有没有atr该元素boolean bol = str1.contains("atr");sop("str1:"+str1);sop("bol:"+bol); *//*若数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素若数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在*///将字符数组变成list集合List<String> str2 = Arrays.asList(str);//将int类型的数组变成list集合// List<int[]> in1 = Arrays.asList(in);//将int引用数据类型数组变成list集合List<Integer> in2 = Arrays.asList(ing);sop(str2);// sop(in1);sop(in2);}//自定义判断集合元素方法public static boolean MyContains(String[] arr, String key){for(int x=0;x<arr.length;x++){if(arr[x].equals(key)){return true;}}return false;}}
小结 :
1. 操作collection时要想到collections工具类;操作数组时要想到arrays工具类
三十. 集合(集合转成数组)
1 ) . 集合变数组 使用 collection接口中的 toArray () 方法
2 ) . Demo:
import java.util.*;/*该节内容讲述了 :集合变数组的方式 : collection接口中的toArray()方法*/class CollectionToArray{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){ArrayList<String> arr = new ArrayList<String>();arr.add("summer");arr.add("sum");arr.add("summ");//将arr集合类型转化为String[]数组类型// String[] str = arr.toArray(new String[0]); // 理解 : 在我们想要把集合转化为数组的时候,需要传入指定类型,长度的数组 -->new String[0] : 此处的零是瞎猜的数组长度/*1.当指定类型的数组到底要定义多长呢?[1] 当指定类型的数组长度小于了集合的size,那么该方法内部汇创建一个新的数组长度为集合的size[2] 当指定类型的数组长度小于了集合的size,那么不会新创建数组,而是使用传递进来的数组[3] 结论 : 因此创建一个刚刚好的数组最优-->通过 str.size() 方法可获取数组长度2.为何要将集合变数组?[1]为了限定对元素的操作,不需要对文件内容进行增删了 例子:系统文件*///将arr集合类型转化为String[]数组类型,长度为arr.size()最优长度,返回String[] 数组类型String[] str = arr.toArray(new String[arr.size()]);//将str数组类型转化为String类型的sop(Arrays.toString(str));}}
小结 :
1. 数组变集合使用 arrays工具类中的asList()方法 ; 集合变数组使用 collection接口中的toArray()方法 ;2. 数组变集合是为了使用集合中大量的方法得以拓展 ; 集合变数组是为了限制集合中大量方法得以保护 ; 例如 增删
三十一. 集合(增强for循环)
1 ) . 增强for是 : 是 iterator 迭代方法 的简化版本 ,有局限性,只能用来获取元素
2 ) . Demo:
import java.util.*;/*该节内容讲述了 :迭代输出的发展史 :for循环 --> iterator()迭代方法 --> ListIterator()对list迭代方法 --> iterator()迭代接口 --> forEach高级for循环的优势:[1] 优势: 使用简化的代码获取集合中的元素[2] 劣势: 只能获取集合元素,不能对集合中的元素进行其它操作[3] 对比: iterator 除了遍历,还可进行remove集合中元素的操作 ; ListIterator除了遍历,还可对集合进行crud的操作高级for循环与传统for循环的区别:[1]高级for有局限性,必须有被遍历的目标 ---> 比如打印100次 helloworld , 它完不成[2]传统for可针对性的制定范围高级for循环的格式:for(数据类型 变量名: 被遍历的集合(collection)或者数组){}*/class CollectionToFor{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){ArrayList<String> arr = new ArrayList<String>();arr.add("summer");arr.add("sum");arr.add("summ");//升级后的遍历方式-->他的底层还是iteratorfor(String s1 : arr){sop(s1);}//原始的遍历方式for(Iterator it= arr.iterator();it.hasNext();){sop(it.next());}//对数组同样可遍历int[] it = {1,2,3};for(int i : it){sop("元素:"+i);}//对无需集合进行操作Map<Integer,String> hs = new HashMap<Integer,String>();hs.put(1,"summer");hs.put(2,"sum");hs.put(3,"summr");//获取键Set<Integer> keyset = hs.keySet();for(Integer key : keyset){sop("key:"+key);}//获取键与值 -->原始方式Set<Map.Entry<Integer,String>> set =hs.entrySet();for(Map.Entry me :set ){sop("原始方式:"+me.getKey()+"::"+me.getValue());}//获取键与值 -->简化方式for(Map.Entry<Integer,String> me : hs.entrySet()){sop("简化方式:"+me.getKey()+"::"+me.getValue());}}}
小结 :
1. List集合有两种取得方式 ,一种是 iterator , 一种是for循环 ; set 集合只有一种取得方式 , 就是 iterator ; List可for循环,是因为它有脚标
三十二
. 集合(可变参数)
1 ) . 简述 : 可变参数就是 让 其传入的不确定数量多少参数值 使用 ...的方式全部省略,并系统自己封装成数组,确定长度
2 ) . Demo :
import java.util.*;/*该节内容讲述了 : 可变参数--> 其实就是上一中数组参数的简写形式,无需每次都手动建立数组,通过int ... ,来操作元素作为参数传递即可,隐式的将这些参数封装成数组*/class ParamMethodDemo{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){//原始方法getInt(1);getInt(1,2);getInt(1,2,3);//升级方法调用int[] in ={1,2,3,4};getIntUp(in);//终极方法调用GetIntUpDate(1,5,4,5,5);}//原始重载public static void getInt(int A){sop("原始方法:"+A);}public static void getInt(int A,int B ){sop("原始方法:"+A+":"+B);}public static void getInt(int A,int B,int C){sop("原始方法:"+A+":"+B+":"+C);}//方法普通升级public static void getIntUp(int[] arr){sop("升级方法:"+arr.length);}//方法终极升级public static void GetIntUpDate(int... arr){sop("终极方法:"+arr.length);}}
小结 :
1. 可变参数用来传入参数类型时
三十三
. 集合(静态导入)
1 ) . 静态代入 : 当需要用到类的时候,我们导入包; 当需要用到类中静态方法是,我们静态导入类 ; 说到底是为了 优化代码
2 ) . Demo:
/*该节内容讲述了 : inport static 静态导入: 用来导入相关类的静态方法,这样方法前可不用类名调用,便可直接使用注意:[1] 当类名重名时,需要指定具体的包名[2]当方法重名时,指定具体所属的对象或者类*/import java.util.*;import static java.util.Arrays.*; //静态导入了arrrays类中的所有静态成员import static java.lang.System.*; //静态导入 了system类中的所有静态成员 -->它导入后 System.out.println("hello world"); --> 可变 out.println("hello world");class StaticImportDemo{public static void sop(Object obj){System.out.println(obj);}//主方法public static void main(String args[]){int[] it ={1,2,3};//排序Arrays.sort(it);//二分查找,返回其角标int dex = Arrays.binarySearch(it,1);sop(dex);//数组变字符串sop(Arrays.toString(it));// 思考: 如何去掉arrays 这个类名,直接调用其方法? 答:采用静态导入//--------------------------------------------------------------//排序sort(it);//二分查找,返回其角标int dex1 = binarySearch(it,1);sop(dex1);//数组变字符串sop(Arrays.toString(it)); //这个arrays不能去的原因是 ,类默认继承object ,而object中也有toString方法,因为必须加类名指定}}
小结 :
1. 静态导入类的中的静态成员是为了优化代码,直接调用方法使用,但需注意当两个类中同时具有相同方法名时,就需要指定类了
三十四
. 总结
1 ) . Iterator可以用来迭代collection集合中的元素 ; keySet ,entrySet 可以用来获取map集合中的元素;
2 ) . 当我们要对array数组进行操作时要先想到arrays这个工具类 ; 当我们要对collection集合进行操作时要先想到collections这个工具类
3 ) . 有角标才可迭代,无角标不可迭代 ;
4 ) . List快但不安全,但可以使用synchronizedList方法让其安全,因此 使用就用list,没毛病
5 ). 数组变集合是为了使用集合中的更多方法 ; 集合变数组是为了限制集合中的方法 ; 例子 : 系统文件是不允许增删的 ; 永远记得 数组不可增删,集合可以crud