Java Day 19

Map集合--LinkedHashMap
 有序 存取一致

package com.company.Day019;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Created by junius on 2016/10/15.
 */
public class HashMap001 {
    public static void main(String[] args){
        HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();
        hm.put(7,"zhouqi");
        hm.put(5,"zhouqi3");
        hm.put(2,"zhouqi2");

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

 
记录字母次数
 --002 TreeMap 有序
 1、将字符串中的字母变成字符数组
 2、遍历字符数组，用每一个字母作为键去查Map集合这个表
    如果该字母键不存在，就将该字母作为键1存储
    如果该字母键存在，就将该字母键对应值取出并+1，然后存储
 3、遍历Map集合

package com.company.Day019;

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

/**
 * Created by junius on 2016/10/10.
 * "fagavcbascdfs" 字母次数  映射关系
 * 1、字符串变成字符数组
 * 2、遍历字符数组，用每一个字母做键 查map表
 * 如果字母键不存在，就值为1
 * 存在,则值+1
 * 3、遍历
 */
public class MainDemo002 {
    public static void main(String[] args){
        String str = "abcefgabcabcooi";
        String s = getCharCount(str);
        System.out.println(s);
    }

    public static String getCharCount(String str) {
        //字符串转换成字符数组
        char[] chs = str.toCharArray();

        //定义map集合
        Map<Character,Integer> map = new TreeMap<Character,Integer>();

        for (int i = 0; i <chs.length ; i++) {
            /*if(value==null)
                map.put(chs[i],1);
            else{
                map.put(chs[i],value+1);
            }*/
            if(!(chs[i] >= 'a' && chs[i] <= 'z' || chs[i] >= 'A' &&chs[i] <= 'Z'))
                continue;
            int count = 0;
            Integer value = map.get(chs[i]);

            if(value != null){
                count = value;
            }
            count++;
            map.put(chs[i],count);
        }

        return mapToString(map);
    }

    private static String mapToString(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查表法
 如果有映射关系，优先考虑map集合

集合框架工具类
 Collections 静态方法
 

package com.company.Day019;

import java.util.*;

public class MapTest003 {
    public static void main(String[] args){

        demo_2();
    }

    private static void demo_2() {
        List<String> list = new ArrayList<String>();
        list.add("zzzA");
        list.add("yyyYY");
        list.add("dd");
        list.add("aaa");
        System.out.println(list);
//        Collections.sort(list);
//        mySort_2(list,new comparatorByLength());
        Collections.sort(list,new comparatorByLength());
        System.out.println(list);

    }

    private static void demo_1() {

        List<String> list = new ArrayList<String>();
        list.add("zzz");
        list.add("yyy");
        list.add("ddd");
        list.add("aaa");
        System.out.println(list);
//        Collections.sort(list);
        mySort(list);
        System.out.println(list);

    }

    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){
//                    String temp = (String)list.get(i);
//                    list.set(i,list.get(j));
//                    list.set(j,(T)temp);
                    Collections.swap(list,i,j);
                }
            }
        }
    }

    public static <T> void mySort_2(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) {
                        Collections.swap(list, i, j);
                    }
                }
            }
    }
}

 sort

 折半
  
 最值
 
 逆序 替换
 Collections.reverseorder 返回比较器
 Collections.reverseorder(比较器)
 reverse(List list)

 replaceAll(list oldValue,newValue) -> set(index,value)

 其他方法 非同步转换成同步
 fill()
 

package com.company.Day019;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by junius on 2016/10/15.
 */
public class Lock004 {
    public static void main(String[] args){
        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{
        @Override
        public List subList(int fromIndex, int toIndex) {
            return null;
        }

        private List list;
        private final Object lock = new Object();

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

    }
}

shuffle（list）
 使用随机源对列表进行置换,类似洗牌

 Arrays--操作容器的方法
   全是静态方法
   toString()
   asList() 将数组转成list集合
   转换前，对象和基本类型数据的区别

package com.company.Day019;

import java.util.Arrays;
import java.util.List;

/**
 * Created by junius on 2016/10/15.
 */
public class Arrays005 {
    public static void main(String[] args){

        demo_2();
//        System.out.println(myToString(arr));
        String[] str = {"abc","abb","abd"};

        //将数组转换成集合
//      好处：可以使用集合的方法
//      弊端：对于集合的增删方法不可用
        List<String> list = Arrays.asList(str);
        boolean b = list.contains("abc");
        System.out.println("list b = "+b);
    }

    private static void demo_2() {
        int[] arr = {2,3,4,5,7};
        List<int[]> list = Arrays.asList(arr);
        System.out.println(list);
    }

    private static String myToString(int[] 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

 ForEach循环
 
 函数可变参数
 
 静态导入
  import static **

package com.company.Day019;

import java.util.*;

/**
 * Created by junius on 2016/10/15.
 * Collection 的 toArray方法
 *
 */
public class toArray006 {
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc4");
        list.add("abc3");
        String[] str = list.toArray(new String[list.size()]);
        //toArray方法需要传入 一个指定类型的数组
        //如果长度小于集合的size,该方法会创建一个同类型并和集合相同size的数组
        //如果长度大于集合的size,则数组中其他多余的位置存储null
        //所以建议长度指定为集合的size.
        //System.out.println(Arrays.toString(str));

        /*foreach语句
         *for(类型 变量 ： Collection集合|数组)
         * 只用于遍历，不会对元素进行过多的操作
         *
         * 与普通for的区别
         * 1、普通for可以定义控制循环的增量和条件
         *    增强for是简化形式，必须要有遍历的目标
         */
        for (String str2 : str) {
            System.out.println(str2);

        }

        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(3,"lisi1");
        map.put(4,"lisi2");
        map.put(2,"lisi3");
        map.put(5,"lisi4");

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

        int sum = add(4,6);

         System.out.print(newAdd(2,1,2,3,4,5,6));

    }

    public static int add(int a,int b){
        return a+b;
    }

    /*
    * 注意事项 可变参数类型，必须定义在参数列表的结尾
    */
    public  static int newAdd(int... arr){
        int sum = 0;
        for (int i = 0; i <arr.length ; i++) {
            sum += arr[i];
        }
        return sum;
    }


}