(十)Core Java 集合框架Map,Map扩展与TreeMap -04 (104)

最新推荐文章于 2024-05-06 03:52:06 发布

Ss_慎独

最新推荐文章于 2024-05-06 03:52:06 发布

阅读量287

点赞数

分类专栏：技术

本文链接：https://blog.csdn.net/modaiairen524/article/details/79538695

版权

技术专栏收录该内容

96 篇文章 1 订阅

订阅专栏

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.*;

/*

集合框架的工具类 : Collections

Max: -->求最大值

*/



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);

                           //将中间值与传入的值相比较,若相等则返回其坐标.若不等返回-1

                           int num = str.compareTo(key);



                           //大于零说明有这个值,那么直接折半 ,折半的方式就是 max=mid-1; -->这个是从大到小

                           if(num>0)

                                 max=mid-1;

                           //小于零则说明没有这个值,那么也直接折半,折半方式就是min=mid+1; -->这个是从小到大

                           else if(num<0)

                                 min=mid+1;

                           else

                               return 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<key

                           int num = cmp.compare(str,key);



                           //大于零说明有这个值,那么直接折半 ,折半的方式就是 max=mid-1; -->这个是从大到小

                           if(num>0)

                                 max=mid-1;

                           //小于零则说明没有这个值,那么也直接折半,折半方式就是min=mid+1; -->这个是从小到大

                           else if(num<0)

                                 min=mid+1;

                           else

                               return 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;

              else

                     return 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");









                     //升级后的遍历方式-->他的底层还是iterator

                     for(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

Ss_慎独

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
(十)Core Java 集合框架Map,Map扩展与TreeMap -04 (104)

目录 : 23). 集合(Coolections-sort)24 ).集合(Collections-max)25 ).集合(Collections-binarySearch)26 ).集合(Collections-替换反转)27 ).集合(Collections-reverseOrder)28 ).集合(Collections-Synlist)29 ).集合(Arrays)30 ).集合(集合转...
复制链接

扫一扫

专栏目录