一、单例模式

饿汉模式
public class Singleton {
    private Singleton(){};

    private static Singleton Instance = new Singleton();

    public static Singleton getInstance(){
        return Instance;
}
懒汉模式
public class Singleton {
    private Singleton(){}
    private static class LazyHodler{
        private static Singleton Instance = new Singleton();
    }
    public static Singleton getInstance(){
        return LazyHodler.Instance;
    }
}

二、数组操作

/**
* 1.获取数组中的最大值/最小值
*/
public static int getMax(int[] arr) {
        int max = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max)
                max = arr[x];
        }
        return max;
}

/**
 * 2.给数组排序，选择排序和冒泡排序
 */
public static void selectSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = x + 1; y < arr.length; y++) {
            if (arr[x] > arr[y]) {
                swap(arr, x, y);
            }
        }
    }
}
public static void swap(int[] arr, int a, int b) {
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
public static void bubbleSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = 0; y < arr.length - x - 1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。
        {
            if (arr[y] < arr[y + 1]) {
                swap(arr, y, y + 1);
            }
        }
    }
}

/**
 * 3.对给定的数组进行反转
 */
public static void reverseArray(int[] arr) {
    for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
        swap(arr, start, end);
    }
}

/**
 * 4.数组的查找操作，
 */
public static int getIndex(int[] arr, int key) {
    for (int x = 0; x < arr.length; x++) {
        if (arr[x] == key)
            return x;
    }
    return -1;
}

//二分法查找，先排序
public static int halfSearch(int[] arr, int key) {
    int min, max, mid;
    min = 0;
    max = arr.length - 1;
    mid = (max + min) / 2;

    while (arr[mid] != key) {
        if (key > arr[mid])
            min = mid + 1;
        else if (key < arr[mid])
            max = mid - 1;

        if (min > max)
            return -1;
        mid = (max + min) / 2;
    }
    return mid;
}

//保留小数点，在四舍五入后
public class TestMath {
    public static void main(String[] args) {
        /*
        Random r = new Random();
        for(int x=0; x<10; x++)
        {
            //int d = (int)(Math.random()*10+1);
            int d = r.nextInt(10)+1;
            sop(d);
        }
        */
        saveTwo(12.3456, 2, true);//12.34
    }

    public static void saveTwo(double d, int scale, boolean isRound) {

        double base = Math.pow(10, scale);
        double num = isRound ? Math.round(d * base) / base : ((int) (d * base)) / base;
        sop("num=" + num);
        /*
        double d1 = d*100;
        sop("d1="+d1);
        d1 = d1+0.5;
        double d2 = (int)d1;
        sop("d2="+d2);
        double d3 = d2/100;
        sop("d3="+d3);
        */
    }
    public static void show() {
        double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
        double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。
        long l = Math.round(12.54);//四舍五入
        sop("d=" + d);
        sop("d1=" + d1);
        sop("l=" + l);
        double d2 = Math.pow(2, 3);
        sop("d2=" + d2);
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

三、字符串操作

/*基本数据类型对象包装类。
byte    Byte
short   short
int     Integer
long    Long
boolean Boolean
float   Float
double  Double
char    Character
基本数据类型转成字符串。
    基本数据类型+""
    包装类.toString(基本数据类型值);
    如： Integer.toString(34);//将34整数变成"34";
字符串转成基本数据类型。
    xxx a = Xxx.parseXxx(String);
    int a = Integer.parseInt("123");
    double b = Double.parseDouble("12.23");
    boolean b = Boolean.parseBoolean("true");
    Integer i = new Integer("123");
    int num = i.intValue();

/**
 * 将字符串变成数组
 * 对数组反转,将数组变成字符串
 */
public static String reverseString(String s, int start, int end) {
    //字符串变数组。
    char[] chs = s.toCharArray();
    //反转数组。
    reverse(chs, start, end);
    //将数组变成字符串。
    return new String(chs);
}

private static void reverse(char[] arr, int x, int y) {
    for (int start = x, end = y - 1; start < end; start++, end--) {
        swap(arr, start, end);
    }
}

private static void swap(char[] arr, int x, int y) {
    char temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
}

/**
 * 去除字符串两端空格
 */
public static String myTrim(String str) {
    int start = 0, end = str.length() - 1;
    while (start <= end && str.charAt(start) == ' ')
        start++;
    while (start <= end && str.charAt(end) == ' ')
        end--;
    return str.substring(start, end + 1);
}

/**
 * 子串在整串中出现的次数。
 */
private static int getCount(String str, String ref) {
    int count = 0;
    while (str.contains(ref)) {
        str = str.substring(str.indexOf(ref) + ref.length());
        count++;
    }
    return count;
}

/**
 * 对字符串中字符进行自然顺序排序。
 * 思路：字符串变成字符数组,对数组排序，选择，冒泡，Arrays.sort(),将排序后的数组变成字符串。
 */

/**
 * 要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。
 * 思路：
 * 1，将字符串切割。变成字符串数组。
 * 2，将字符串数组转成int数组。
 * 3，int数组排序。
 * 4，将int数组变成字符串。
 */
public static String numberStringSort(String str) {
    String[] arr = splitString(str);
    int[] nums = toIntArray(arr);
    Arrays.sort(nums);
    return intArraytoString(nums);
}
private static String[] splitString(String str) {
    return str.split(" ");
}
private static int[] toIntArray(String[] arr) {
    int[] nums = new int[arr.length];

    for (int x = 0; x < arr.length; x++) {
        nums[x] = Integer.parseInt(arr[x]);
    }
    return nums;
}
private static String intArraytoString(int[] arr) {
    StringBuilder sb = new StringBuilder();

    for (int x = 0; x < arr.length; x++) {
        if (x != arr.length - 1)
            sb.append(arr[x] + " ");
        else
            sb.append(arr[x]);
    }
    return sb.toString();
}

/**
 * 获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印
 * "abcwerthelloyuiodef"  "cvhellobnm"
 * 思路：将短的那个子串按照长度递减的方式获取到,将每获取到的子串去长串中判断是否包含,如果包含，已经找到！
 */
public static String getMaxSubString(String s1, String s2) {

    String max = "", min = "";

    max = (s1.length() > s2.length()) ? s1 : s2;

    min = (max == s1) ? s2 : s1;

    for (int x = 0; x < min.length(); x++) {
        for (int y = 0, z = min.length() - x; z != min.length() + 1; y++, z++) {
            String temp = min.substring(y, z);
            //sop(temp);
            if (max.contains(temp))//if(s1.indexOf(temp)!=-1)
                return temp;
        }
    }
    return "";
}

四、集合操作

/*Collection定义了集合框架的共性功能。
        1，添加
        add(e);
        addAll(collection);

        2，删除
        remove(e);
        removeAll(collection);
        clear();

        3，判断。
        contains(e);
        isEmpty();

        4，获取
        iterator();
        size();

        5，获取交集。
        retainAll();

        6，集合变数组。
        toArray();

        1，add方法的参数类型是Object。以便于接收任意类型对象。

        2，集合中存储的都是对象的引用(地址)


        什么是迭代器呢？
        其实就是集合的取出元素的方式。
        如同抓娃娃游戏机中的夹子。

        迭代器是取出方式，会直接访问集合中的元素。
        所以将迭代器通过内部类的形式来进行描述。
        通过容器的iterator()方法获取该内部类的对象。
*/

• List

/**
 * Created by joshul on 2017/3/6.
 * ArrayList 数组形式访问List链式集合数据，元素可重复，访问元素较快  数组
 * LinkedList 链表方式的List链式集合，元素可重复，元素的插入删除较快 双向链表
 */
public class TestList {
    public static void main(String[] args) {

    }

    /**
     * ArrayList 数组形式访问List链式集合数据，元素可重复，访问元素较快  数组
     * @param al
     * @return
     */
    public static ArrayList singleElement(ArrayList al) {
        //定义一个临时容器。
        ArrayList newAl = new ArrayList();
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newAl.contains(obj))
                newAl.add(obj);
        }
        return newAl;
    }
}

• Set

/**
 * Created by joshul on 2017/3/6.
 * Set的核心概念就是集合内所有元素不重复。在Set这个子接口中没有在Collection特别实现什么额外的方法，应该只是定义了一个Set概念。
 * 下面我们来看Set的几个常用的实现HashSet、LinkedHashSet、TreeSet
 * <p>
 * HashSet  无序的、无重复的数据集合    基于HashMap
 * LinkedSet    维护次序的HashSet    基于LinkedHashMap
 * TreeSet  保持元素大小次序的集合，元素需要实现Comparable接口  基于TreeMap
 */
public class TestSet {

    /**
     * "90 -7 0 18 2 45 4",将字符串中的数值进行排序。使用TreeSet完成。
     * 将字符串切割,可以将这些对象存入TreeSet集合。因为TreeSet自身具备排序功能。
     */
    public static void main(String[] args) {
        String str = "90 -7 0 18 2 45 4";
        String[] arr = str.split(" ");
        TreeSet ts = new TreeSet();
        for (int x = 0; x < arr.length; x++) {
            //ts.add(new Integer(arr[x]));
            ts.add(Integer.parseInt(arr[x]));//
        }
        System.out.println(ts);
    }
}

• Mep

public class TestMap {
    public static void main(String[] args) {
        String s= charCount("ak+abAf1c,dCkaAbc-defa");
        System.out.println(s);
    }

    /**
     * "sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
     * 希望打印结果：a(1)c(2).....
     * 思路:
     * 1，将字符串转换成字符数组。因为要对每一个字母进行操作。
     * 2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合
     * 3，遍历字符数组。
     * 将每一个字母作为键去查map集合。
     * 如果返回null，将该字母和1存入到map集合中。
     * 如果返回不是null，说明该字母在map集合已经存在并有对应次数。那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
     * 4，将map集合中的数据变成指定的字符串形式返回。
     */
    public static String charCount(String str) {
        char[] chs = str.toCharArray();

        TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
        int count = 0;
        for (int x = 0; x < chs.length; x++) {
            if (!(chs[x] >= 'a' && chs[x] <= 'z' || chs[x] >= 'A' && chs[x] <= 'Z'))
                continue;
            Integer value = tm.get(chs[x]);
            if (value != null)
                count = value;
            count++;
            tm.put(chs[x], count);//直接往集合中存储字符和数字，为什么可以，因为自动装箱。
            count = 0;
        }
        //System.out.println(tm);
        StringBuilder sb = new StringBuilder();
        Set<Map.Entry<Character, Integer>> entrySet = tm.entrySet();
        Iterator<Map.Entry<Character, Integer>> it = entrySet.iterator();

        while (it.hasNext()) {
            Map.Entry<Character, Integer> me = it.next();
            Character ch = me.getKey();
            Integer value = me.getValue();
            sb.append(ch + "(" + value + ")");
        }
        return sb.toString();
    }
}

四、IO操作

/**
 * Created by joshul on 2017/3/1.
 * IO流用来处理设备之间的数据传输
 * Java对数据的操作是通过流的方式
 * Java用于操作流的对象都在IO包中
 * 流按操作数据分为两种：字节流与字符流
 * 流按流向分为：输入流，输出流。
 * 字节流的抽象基类： InputStream ，OutputStream。
 * 字符流的抽象基类： Reader ， Writer。
 * InputStream的子类FileInputStream。
 * Reader的子类FileReader。
 * IO程序的书写:
 * 导入IO包中的类
 * 进行IO异常处理
 * 在finally中对流进行关闭
 * <p>
 * 字符流的缓冲区
 * 缓冲区的出现提高了对数据的读写效率。
 * 对应类: BufferedWriter, BufferedReader
 * 缓冲区要结合流才可以使用,在流的基础上对流的功能进行了增强。
 * <p>
 * 装饰设计模式:对原有类进行了功能的改变，增强。
 */

public class Io {
    public static void main(String[] args) {
        getTime();
    }

    /**
     * 获取现在时间
     */
    public static void getTime() {
        Date d = new Date();
        System.out.println(d);//打印的时间看不懂，希望有些格式。
        //将模式封装到SimpleDateformat对象中。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
        //调用format方法让模式格式化指定Date对象。
        String time = sdf.format(d);
        System.out.println("time=" + time);
        long l = System.currentTimeMillis();
        Date d1 = new Date(l);
        System.out.println("d1:" + d1);
    }

    /**
     * 读取一个.java文件，并打印在控制台上。
     */
    public static void readJava() {
        FileReader fr = null;
        try {
            fr = new FileReader("DateDemo.java");
            char[] buf = new char[1024];
            int num = 0;
            while ((num = fr.read(buf)) != -1) {
                System.out.print(new String(buf, 0, num));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 演示对已有文件的数据续写。
     */
    public static void readFile() {
        FileWriter fw = null;
        try {
            //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
            fw = new FileWriter("demo.txt", true);
            fw.write("nihao\r\nxiexie");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * FileWriter
     */
    public static void fileWriter() {
        FileWriter fw = null;
        try {
            //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
            //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
            //其实该步就是在明确数据要存放的目的地。
            fw = new FileWriter("demo.txt");
            //调用write方法，将字符串写入到流中。
            fw.write("abcde");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //刷新流对象中的缓冲中的数据。
                //将数据刷到目的地中。
                //fw.flush();
                //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
                //将数据刷到目的地中。
                //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        /*//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
        FileWriter fw = new FileWriter("demo.txt",true);

        fw.write("nihao\r\nxiexie");

        fw.close();*/
    }
}

**
 * Created by joshul on 2017/3/6.
 * 字符流：FileReader FileWriter。/BufferedReader BufferedWriter
 * 字节流：InputStream  OutputStream
 * 需求，想要操作图片数据。这时就要用到字节流。
 */
public class TestBuffer {
    public static void main(String[] args){

    }
    public static void BufferedReader() {
        FileReader fr = null;
        BufferedReader bufr = null;
        try {
            //创建一个读取流对象和文件相关联。
            fr = new FileReader("buf.txt");
            //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
            bufr = new BufferedReader(fr);
            String line = null;
            while ((line = bufr.readLine()) != null) {
                System.out.print(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /*public static void BufferedWriter() {
        //创建一个字符写入流对象。
        FileWriter fw = new FileWriter("buf.txt");
        //为了提高字符写入流效率。加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);
        for(int x=1; x<5; x++)
        {
            bufw.write("abcd"+x);
            bufw.newLine();
            bufw.flush();
        }
        //记住，只要用到缓冲区，就要记得刷新。
        //bufw.flush();
        //其实关闭缓冲区，就是在关闭缓冲区中的流对象。
        bufw.close();
    }*/
}

四、SQL题

1.写一个sql将表TEST_A(ID,NAME,CODE)中重复次数大于2的NAME值打印出来

select NAME from TEST_A
where NAME in(select NAME from TEST_A group by NAME having count(NAME)>2);

2.用一条SQL 语句 查询出每门课都大于80 分的学生姓名student_tb

name kecheng fenshu
张三 语文 81
张三 数学 75

select name from student_tb where fenshu in(select fenshu from student_tb group by having min(fenshu)>80);

3.学生表 如下:student_tb

自动编号 学号 姓名 课程编号 课程名称 分数
1 2005001 张三 0001 数学 69
2 2005002 李四 0001 数学 89
3 2005001 张三 0001 数学 69
删除除了自动编号不同, 其他都相同的学生冗余信息

delete from student_tb where 自动编号 not in(select min(自动编号) from student_tb group by 学号,姓名,课程编号,课程名称,分数)

4.一个叫 team 的表,里面只有一个字段name, 一共有4 条纪录,分别是a,b,c,d, 对应四个球队,现在四个球队进行比赛,用一条sql 语句显示所有可能的比赛组合.

select a.name,b.name from student2 a, student2 b
where a.name<b.name;

5.请用SQL 语句实现:从TestDB 数据表中查询出所有月份的发生额都比101 科目相应月份的发生额高的科目.请注意:TestDB 中有很多科目,都有1 -12 月份的发生额.

AccID :科目代码,Occmonth :发生额月份,DebitOccur :发生额.
数据库名:JcyAudit,数据集:Select * from TestDB

select a.* from TestDB as a,(select Occmonth,max(DebitOccur) Debit101ccur from TestDB where AccID= '101' group by Occmonth) b
where a.Occmonth = b.Occmonth and a.DebitOccur > b.Debit101ccur

6. 面试题:怎么把这样一个表儿

year month amount
1991 1 1.1
1991 2 1.2
1991 3 1.3
1991 4 1.4
1992 1 2.1
1992 2 2.2
1992 3 2.3
1992 4 2.4
查成这样一个结果
year m1 m2 m3 m4
1991 1.1 1.2 1.3 1.4
1992 2.1 2.2 2.3 2.4

select year,(select amount from table_aa m where month = 1 and table_aa.year = m.year) as m1,() as m2,() as m3 from table_aa
group by year;

7. 说明:复制表( 只复制结构, 源表名:a 新表名:b)

select * into b from a where 1<>1 (where1=1,拷贝表结构和数据内容)

7. 说明:拷贝表( 拷贝数据, 源表名:a 目标表名:b)

insert into b(a, b, c) select d,e,f from a;

8. 说明:显示文章.提交人和最后回复时间

select a.title a.name b.adddate from table a ,(select max(adddate) adddate from table where a.title = table.title) b

9. 说明:外连接查询( 表名1 :a 表名2 :b)

select a.a,a.b,a.c,b.c,b.d,b.f from a left outer join b on a.a = b.c

10. 说明:日程安排提前五分钟提醒

select * from 日程安排 where datediff('minute',f 开始时间,getdate())>5

11. 说明:两张关联表,删除主表中已经在副表中没有的信息

Delete from info where not exists (select * from infobz where info.infid=infobz.infid )

12. 有两个表A 和B ,均有key 和value 两个字段,如果B 的key 在A 中也有,就把B 的value 换为A 中对应的value

这道题的SQL 语句怎么写?
update b set b.value=(select a.value from a where a.key=b.key) where b.id in(select b.id from b,a where b.key=a.key);

SQL面试题

1 触发器的作用?

答：触发器是一中特殊的存储过程，主要是通过事件来触发而被执行的。它可以强化约束，来维护数据的完整性和一致性，可以跟踪数据库内的操作从而不允许未经许可的更新和变化。
可以联级运算。如，某表上的触发器上包含对另一个表的数据操作，而该操作又会导致该表触发器被触发。

2 什么是存储过程?用什么来调用?

答：存储过程是一个预编译的 SQL 语句，优点是允许模块化的设计，就是说只需创建一次，以后在该程序中就可以调用多次。如果某次操作需要执行多次 SQL ，
使用存储过程比单纯 SQL 语句执行要快。可以用一个命令对象来调用存储过程。

3 索引的作用?和它的优点缺点是什么?

答：索引就一种特殊的查询表，数据库的搜索引擎可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，
创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。

3 什么是内存泄漏?

答：一般我们所说的内存泄漏指的是堆内存的泄漏。堆内存是程序从堆中为其分配的，大小任意的，使用完后要显示释放内存。当应用程序用关键字 new 等创建对象时，就从堆中为它分配一块内存，
使用完后程序调用 free 或者 delete 释放该内存，否则就说该内存就不能被使用，我们就说该内存被泄漏了。

4 维护数据库的完整性和一致性,你喜欢用触发器还是自写业务逻辑?为什么?

答：我是这样做的，尽可能使用约束，如 check, 主键，外键，非空字段等来约束，这样做效率最高，也最方便。其次是使用触发器，这种方法可以保证，
无论什么业务系统访问数据库都可以保证数据的完整新和一致性。最后考虑的是自写业务逻辑，但这样做麻烦，编程复杂，效率低下。

5 什么是事务?什么是锁?

答：事务就是被绑定在一起作为一个逻辑工作单元的 SQL 语句分组，如果任何一个语句操作失败那么整个操作就被失败，以后操作就会回滚到操作前状态，或者是上有个节点。
为了确保要么执行，要么不执行，就可以使用事务。要将有组语句作为事务考虑，就需要通过 ACID 测试，即原子性，一致性，隔离性和持久性。
锁：在所以的 DBMS 中，锁是实现事务的关键，锁可以保证事务的完整性和并发性。与现实生活中锁一样，它可以使某些数据的拥有者，在某段时间内不能使用某些数据或数据结构。当然锁还分级别的。

6 什么叫视图?游标是什么?

答：视图是一种虚拟的表，具有和物理表相同的功能。可以对视图进行增，改，查，操作，试图通常是有一个表或者多个表的行或列的子集。对视图的修改不影响基本表。它使得我们获取数据更容易，相比多表查询。
游标：是对查询出来的结果集作为一个单元来有效的处理。游标可以定在该单元中的特定行，从结果集的当前行检索一行或多行。可以对结果集当前行做修改。一般不使用游标，但是需要逐条处理数据的时候，游标显得十分重要。

题目补充

1.写一个sql将表TEST_A(ID,NAME,CODE)中重复次数大于2的NAME值打印出来（15）
select NAME from TEST_A
where NAME in(select NAME from TEST_A group by NAME having count(NAME)>2);

2.写一段代码获取结构 List<Map<String,String>>中各个Map，并通过System.out.println()打印出来（15）
/**
 * 将指定的 结构为 List<Map<String,String>>的参数 通过System.out.println()打印出来
 * 格式："键名：键值"
 * @param List<Map<String,String>>
 *
 */
public void printOut(List<Map<String,String>>){

    List<Map<String,Object>> list= List<Map<String,String>>
    for (int i=0;i<list.size(),i++)
    {
    Map map=(Map)list.get(i);
    Iterator iterator = map.keySet().iterator();
    while (iterator.hasNext())
    {
    String key = (String) iterator.next();
    Object object = map.get(key);
    }
    }
}

3.有类似这样的一串字符"abcddeffx.asre-321!assra..",请实现以下方法将字符串各个字符的出现的次数统计出来
/**
 * 将指定的 结构为 List<Map<String,String>>的参数 通过System.out.println()打印出来
 * 格式："键名：键值"
 * @param List<Map<String,String>>
 * @return Map<字符,出现的次数>
 */
 public Map<Character,Integer> staticCharcnt(String str){

 }

4.在一个文本文件（文件大小不超过2k）中存放了很多以空格分隔的英语单词，请写一段伪代码或用文字描述来实现，已得到没有重复的、且按字典顺序排序的所有单词（20分）

首先实现做一个SortedMap,这个Map的Comparator是根据字母顺序排列的一个规则.



5.请用javascript语言解析如下json对象，取出对象中所有数据或将其显示在页面上。（15）
var user = {
    "username" : "andy",
    "age" : 25,
    "info" : {"tell":"123","cellphone":"13766"}
    "address" : [
                    {"city":"北京建国门大街"}
                    {"city":"天津海泰信息广场"}
                ]
}

<table border="1">
    <tr>
        <td>user.username</td>
        <td>user.age</td>
        <td>user.info.tell</td>
        <td>(user.address[0].city</td>
        <td>user.address[1].city</td>
    </tr>
</table>


6.在项目中一导入jquery1.7库，请实现用jquery查找下列表格的第二行第三列的值。（15）

<table id= "tab">
    <tbody>
        <tr>
            <td>第一行第一列</td>
            <td>第一行第二列</td>
            <td>第一行第三列</td>
            <td>第一行第四列</td>
        </tr>
        <tr>
            <td>第二行第一列</td>
            <td>第二行第二列</td>
            <td>第二行第三列</td>
            <td>第二行第四列</td>
        </tr>
    </tbody>
</table>
$('#tab tr').eq(1).find('td').eq(2)