day19_Map集合+集合框架工具类

09-常用对象API(集合框架-Map集合-LinkedHashMap&关联源码)

HashMap<Integer,String>hm = newLinkedHashMap<Integer,String>();

       

        hm.put(7, "zhouqi");

        hm.put(3, "zhangsan");

        hm.put(1, "qianyi");

        hm.put(5, "wangwu");

       

        Iterator<Map.Entry<Integer,String>>it = hm.entrySet().iterator();

       

        while(it.hasNext()){

            Map.Entry<Integer,String> me = it.next();

           

            Integer key = me.getKey();

            String value = me.getValue();

           

            System.out.println(key+":"+value);

        }

 

10-常用对象API(集合框架-Map集合练习-记录字母次数思路)

11-常用对象API(集合框架-Map集合练习-记录字母次数代码)

这里面将一个字符串变成一个字符数组，这个方法忘了怎么办也，你知道有这么一个功能，去分析结果，返回的是字符数组吧，你然后直接去找这个方法，以后再忘了，就用这种分析方法去分析

 

/*

 * 练习:

 * "fdgavcbsacdfs" 获取该字符串中，每一个字母出现的次数。

 * 要求打印结果是：a(2)b(1)...;

 * 思路：

 * 对于结果的分析发现，字母和次数之间存在着映射的关系。而且这种关系很多。

 * 很多就需要存储，能存储映射关系的容器有数组和Map集合。

 * 关系一方式有序编号吗？没有！

 * 那就是使用Map集合。 又发现可以保证唯一性的一方具备着顺序如 a b c ...

 * 所以可以使用TreeMap集合。

 *

 * 这个集合最终应该存储的是字母和次数的对应关系。

 *

 * 1，因为操作的是字符串中的字母，所以先将字符串变成字符数组。

 * 2，遍历字符数组，用每一个字母作为键去查Map集合这个表。

 * 如果该字母键不存在，就将该字母作为键 1作为值存储到map集合中。

 * 如果该字母键存在，就将该字母键对应值取出并+1，在将该字母和+1后的值存储到map集合中，

 * 键相同值会覆盖。这样就记录住了该字母的次数.

 * 3，遍历结束，map集合就记录所有字母的出现的次数。oy.

 *

 *

 */

 

public class MapTest {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

 

       

        String str = "fdg+avAdc  bs5dDa9c-dfs";

       

        String s = getCharCount(str);

       

        System.out.println(s);

       

    }

 

    public static StringgetCharCount(Stringstr) {

       

       

        //将字符串变成字符数组

        char[] chs = str.toCharArray();

       

        //定义map集合表。

        Map<Character,Integer>map = newTreeMap<Character,Integer>();

       

        for (int i = 0; i < chs.length; i++) {

           

            if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))

//          if(!(Character.toLowerCase(chs[i])>='a' &&Character.toLowerCase(chs[i])<='z'))

                continue;

           

            //将数组中的字母作为键去查map表。         

            Integer value = map.get(chs[i]);

           

            int count = 1;

           

            //判断值是否为null.

            if(value!=null){

                count = value+1;

            }

//          count++;

            map.put(chs[i], count);

            /*

            if(value==null){

                map.put(chs[i],1);

            }else{

                map.put(chs[i],value+1);

            }

            */

        }

       

        return mapToString(map);

    }

 

    private static StringmapToString(Map<Character, Integer> map) {

       

        StringBuilder sb = new StringBuilder();

       

        Iterator<Character>it = map.keySet().iterator();

       

        while(it.hasNext()){

            Character key = it.next();

            Integer value = map.get(key);

           

            sb.append(key+"("+value+")");

        }

       

        return sb.toString();

    }

 

Map在有映射关系时，可以优先考虑。

         

 在查表法中的应用较为多见。

 

13-常用对象API(集合框架-工具类-Collections-排序)

我这元素有重复，并且要对它进行排序,没有这种集合怎么办也,就使用工具,下面事例

public 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,newComparatorByLength());

        Collections.sort(list,new ComparatorByLength());

        System.out.println(list);

    }

    public static <T> void mySort(List<T>list,Comparator<? super T> comp){

       

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

           

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

               

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

                   

                }

            }

        }

    }

   

   

    public static <T extends Comparable<? super T>> void mySort(List<T>list){

       

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

           

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

                   

                }

            }

        }

    }

14-常用对象API(集合框架-工具类-Collections-折半&最值)

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

//      Collections.sort(list);

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

    }

 

15-常用对象API(集合框架-工具类-Collections-逆序&替换)

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

        System.out.println(list);

    }

 

    public 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= newTreeSet<String>(Collections.reverseOrder(new ComparatorByLength())); 

       

        ts.add("abc");

        ts.add("hahaha");

        ts.add("zzz");

        ts.add("aa");

        ts.add("cba");

       

        System.out.println(ts);

       

    }

 

16-常用对象API(集合框架-工具类-Collections-其他方法&将非同步集合转成同步集合的方法)

List list = new ArrayList();//非同步的。

 

list = MyCollections.synList(list);//返回一个同步的list.

 

 

 

 

 

 

 

给非同步的集合加锁。

 

class MyCollections{

 

    publicstatic  List synList(List list){

       

        return new MyList(list);

    }

 

    privateclass MyList implements List{

    privateList list;

   

    privatestatic final Object lock = new Object();

    MyList(Listlist){  

        this.list = list;

    }

   

    publicboolean add(Object obj){

        synchronized(lock)

        {

            returnlist.add(obj);

        }

    }

   

    publicboolean remove(Object obj){

        synchronized(lock)

        {

            returnlist.remove(obj);

        }

    }

 

}

}

 

17-常用对象API(集合框架-工具类-Arrays-方法介绍)

 

int[] arr = {3,1,5,6,3,6};

 

//toString的经典实现。

    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(", ");

        }

    }

18-常用对象API(集合框架-工具类-Arrays-asList方法)

/*

         * Arrays：集合框架的工具类。里面的方法都是静态的。

         *

         */

       

//      int[] arr ={3,1,5,6,3,6};     

//      System.out.println(Arrays.toString(arr));

       

        demo_2();

    }

 

    public static void demo_2() {

       

        /*

         * 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。

         *

         * 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。

         *

         */

        int[] arr = {31,11,51,61};

       

        List<int[]> list = Arrays.asList(arr);

       

        System.out.println(list);

    }

 

    /**

     *

     */

    public 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 contaisn:="+b1);

//      list.add("hiahia");//UnsupportedOperationException

       

        System.out.println(list);

    }

   

    public static boolean myContains(String[]arr,String key){

        for (int i = 0; i < arr.length; i++) {

            if(arr[i].equals(key))

                return true;

        }

        return false;

    }

19-常用对象API(集合框架-工具类-Collection-toArray方法

 

/*

         * 集合转成数组呢？

         *

         * 使用的就是Collection接口中的toArray方法。

         *

         * 集合转成数组：可以对集合中的元素操作的方法进行限定。不允许对其进行增删。

         *

         *

         */

       

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

 

 

20-常用对象API(集合框架-JDK5.0特性-ForEach循环)

 

/*

         * foreach语句：

         * 格式：

         * for(类型  变量   ：Collection集合|数组)

         * {

         *    

         * }

         *

         * 传统for和高级for的区别？

         * 传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件。

         *

         * 高级for是一种简化形式。

         * 它必须有被遍历的目标。该目标要是数组，要么是Collection单列集合。

         *

         * 对数数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。

         * 如果要对数组的角标进行操作建议使用传统for。

         * 

         */

       

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

        }

21-常用对象API(集合框架-JDK5.0特性-函数可变参数)

int sum = newAdd(5,1,4,7,3);

        System.out.println("sum="+sum);

        int sum1 = newAdd(5,1,2,7,3,9,8,7,6);

        System.out.println("sum1="+sum1);

       

    }

    /*

     * 函数的可变参数。

     * 其实就是一个数组，但是接收的是数组的元素。

     * 自动将这些元素封装成数组。简化了调用者的书写。

     *

     * 注意：可变参数类型，必须定义在参数列表的结尾。

     *

     */

    public static int newAdd(int a,int...  arr){

       

        int sum = 0;

        for (int i = 0; i < arr.length; i++) {

            sum+=arr[i];

        }

        return sum;

       

//      System.out.println(arr);    

//      return 0;

    }

22-常用对象API(集合框架-JDK5.0特性-静态导入)

import static java.util.Collections.*;//静态导入，其实到入的是类中的静态成员。

 

sort(list);

       

        System.out.println(list);

       

       

        String max = max(list);