11月8到9号的学习(第6、7天)

计划
复习JSON

结果
今天的单词
final  file  Bytes finally get

//引用包
/* 注意:
* 引用java
*/
import java.lang.reflect.Array;

//引用包
/* 注意:
* 类提供了动态创建和访问数组元素的各种静态方法
*/
import java.util.ArrayList;

//引用包
/* 注意:
* 提供公共的执行操作方法的接口
*/
import java.util.Collection;

//引用包
/* 注意:
* 提供公共的执行操作方法的基于哈希表的 Map 接口的实现
*/
import java.util.HashMap;

//引用包
/* 注意:
* 提供公共的执行操作方法的对 collection 进行迭代的迭代器
*/
import java.util.Iterator;

//引用包
/* 注意:
* 提供公共的执行操作方法的列表
*/
import java.util.List;

//引用包
/* 注意:
* 提供公共的执行操作方法的映射到值的对象
*/
import java.util.Map;

//引用包
/* 注意:
* 提供公共的执行操作方法的接口
*/
import java.util.Map.Entry; 

//公共的类名
/**
* JsDataTools 类
* @author xinjie
*
*/
/*
* JS数据交换格式
* @version v0.1
* @author longHP
*/ 
public class JsDataTools { 

    //定义方法
    /**
     * getJsData() 方法
     * @param Object obj
     * @return createJsData(obj)
     */
    /*
     * 获取js数据
     * @param 元数据map
     * @return js数据
     */ 
    public synchronized static String getJsData(Object obj) {
    //返回值
        return createJsData(obj); 
    }
   
    //自动生成   
    @SuppressWarnings("unchecked")
   
    //定义方法
    /**
     * createJsData()方法
     * @param Object obj
     * @return"\"\""
     */
    /* 注意:
     * 生成js数据
     * @param 元数据map
     * @return js数据
     */
    public static String createJsData(Object obj) {
   
    //if语句
    /* 注意：
    * 如果null等于odj
    */
        if (null == obj) {
       
        //返回值
            return "\"\""; 
        }
       
        //创建实例化对象
        /* 注意:
         * StringBuffer
         * 线程安全的可变字符序列
         */
        StringBuffer resultStr = new StringBuffer(); 
       
        //if语句
        /* 注意:
         * 如果obj
         * instanceof
         * 作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据
         * Collection
         * 集合List、Set等类型
         */
        if (obj instanceof Collection) {
       
        //调用方法
            resultStr.append("[");
           
            //把接口类型的obj赋值给接口卡类型collection
            Collection collection = (Collection) obj;
           
            //if语句
            /* 注意:
             * 接口类型的collection的存储空间>0
             */
            if (collection.size() > 0) {
           
            //获得返回包含此 collection 中所有元素的数组给元素的表示数组形式的collectionObj
                Object[] collectionObj = collection.toArray();
               
                //if语句
                /* 注意:
                 * 字符型i = 0 i < collectionObj的数组长度 i+1
                 */
                for (int i = 0; i < collectionObj.length; i++) { 
               
                //将createJsData方法参数追加到序列resultSrr
                    resultStr.append(createJsData(collectionObj[i]) + ","); 
                }
               
                //resultStr移除此序列指定位置的 char参数
                resultStr.deleteCharAt(resultStr.lastIndexOf(",")); 
            }
           
            //调用方法
            resultStr.append("]");
           
          //if语句
          /* 注意:
           * 否则如果 Obj
           * 作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据
           * Map类型
           */
        } else if (obj instanceof Map) {   
       
        //调用方法
            resultStr.append("{");
           
            //将Map里面所有映射的 obj给Map类型的map
            Map map = (Map) obj; 
           
            //if语句
            /* 注意:
             * map储存空间 > 0
             */
            if (map.size() > 0) {
           
            //将map对象迭代的迭代器给iter
            /* 注意:
            * Iterator
            * 迭代器泛型里面是
            * Entry
            * 接口
            */
                Iterator<Entry> iter = map.entrySet().iterator(); 
               
                //whlie循环语句
                /* 注意;
                 * while
                 * 循环条件
                 * iter
                 * hasNext()
                 * 是否还有下一个
                 */
                while (iter.hasNext()) { 
               
                    //引用调用方法
                    Map.Entry entry = iter.next(); 
                   
                    //引用
                    String key = entry.getKey().toString(); 
                   
                    //调用方法
                    resultStr.append("\"" + key + "\":");   
                   
                    //引用调用方法
                    Object tempObj = entry.getValue(); 
                   
                    //调用方法
                    resultStr.append(createJsData(tempObj) + ","); 
                } 
               
              //调用方法
                resultStr.deleteCharAt(resultStr.lastIndexOf(",")); 
            } 
           
          //调用方法
            resultStr.append("}");
           
          //if语句
        } else {   
       
        //如果有异常
            try { 
           
            //参数引用调用方法
                int arrLength = Array.getLength(obj); 
               
                //调用方法
                resultStr.append("["); 
               
                //if语句
                if (arrLength > 0) {
               
                //for循环
                    for (int i = 0; i < arrLength; i++) {
                   
                    //调用方法
                        resultStr.append(createJsData(Array.get(obj, i)) + ","); 
                    } 
                   
                    //调用方法
                    resultStr.deleteCharAt(resultStr.lastIndexOf(",")); 
                } 
               
                //调用方法
                resultStr.append("]"); 
               
              //如果有异常在这里进行捕捉
            } catch (IllegalArgumentException e) {   
           
            //调用方法
                resultStr.append("\"" + stringToJson(obj + "") + "\""); 
            } 
        } 
       
        //返回值
        return resultStr.toString(); 
    } 
     
    /**
     * 处理特殊字符
     * @param json字符串
     * @return 处理过的字符串
     */ 
    public static String stringToJson(String str) { 
   
    //创建实例化对象
        StringBuffer sb = new StringBuffer();
       
        //for循环
        for (int i = 0; i < str.length(); i++) {
       
        //一定参数调用方法
            char c = str.charAt(i);
           
            //语句的判断条件可以接受int,byte,char,short,不能接受其他类型
            switch (c) {
           
                //声明变量  case语句可以不用大括号
                case '\"': 
                    sb.append("\\\"");
                   
                    //表示当i>=10的时候，就跳出循环，执行while后面的代码
                    break; 
                case '\\': 
                    sb.append("\\\\"); 
                    break; 
                case '/': 
                    sb.append("\\/"); 
                    break; 
                case '\b': 
                    sb.append("\\b"); 
                    break; 
                case '\f': 
                    sb.append("\\f"); 
                    break; 
                case '\n': 
                    sb.append("\\n"); 
                    break; 
                case '\r': 
                    sb.append("\\r"); 
                    break; 
                case '\t': 
                    sb.append("\\t"); 
                    break; 
                default: 
                    sb.append(c); 
            } 
        } 
        return sb.toString(); 
    } 
     
    @SuppressWarnings("unchecked") 
   
    /**
     * main() 方法
     * @param String[] args
     * 返回值为空
     */
    public static void main(String[] args) { 
   
    //创建实例化对象
        Map<String, Object> map = new HashMap<String, Object>();
       
        //调用方法
        map.put("a", "1"); 
       
        //调用方法
        map.put("b", "2"); 
       
        //参数赋值
        int[] intArr = {1,2,3};
       
        //调用方法
        map.put("intArr", intArr); 
       
        //创建实例化对象
        Map childMap = new HashMap(); 
       
        //调用方法
        childMap.put(3, 5); 
       
        //创建实例化对象
        childMap.put(7, new HashMap()); 
       
        //调用方法
        childMap.put(new Object(), intArr); 
       
        //调用方法
        map.put("map", childMap);
       
        //创建实例化对象
        List childList = new ArrayList();
       
        //调用方法
        childList.add(true); 
       
        //调用方法
        childList.add(new ArrayList());
       
        //调用方法
        childList.add(intArr); 
       
        //调用方法
        map.put("list1", childList); 
       
        //输出
        System.out.println(JsDataTools.getJsData(map)); 
    } 
} 


//引用包
/* 注意:
* 修改
*/
import java.util.ArrayList;

//引用包
/* 注意:
* 提供公共的执行操作方法的列表e
*/
import java.util.List;

//公共类名
/**
* Get()类
* @author xinjie
*
*/
public class Get {

//定义主方法
/**
* main()方法
* @param String[] args
* @throws Exception
* return 无
*/
public static void main(String[] args) throws Exception {

//定义变量
/* 注意:
* \
* 转义字符
*/
String s1 = "{\"firsName\":\"Brett\",\"lastName\":\"McLaughlin\",\"email\":\"aaaa\"}";

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\{", "");

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\}", "");

//将s1将一个字符串分割为子字符串，然后将结果作为字符串数组返回String[] a1
String[] a1 = s1.split(",");

//创建实例化对象
/* 注意:
* 将修改后的泛型String数组实例化给列表泛型的String数组
*/
List<String[]> arraylist = new ArrayList<String[]>();

//for循环
/* 注意:
* 每次取数组中一个元素，采取遍历方式
*/
for(String s : a1){

//定义变量
/* 注意:
* s将一个字符串分割为子字符串，然后将结果作为字符串数组返回参数遍历
* 赋值被String数组类的m
*/
String[] m = s.split(":");

//调用方法
arraylist.add(m);
}

//for循环
for(String[] m : arraylist){

//if语句
/* 注意:
* m数组的第一个等于email
*/
if(m[0].equals("\"email\"")){

//输出
System.out.println(m[1]);
}
}
}
}


//引用包
/* 注意:
* 修改
*/
import java.util.ArrayList;

//引用包
/* 注意:
* 提供公共的执行操作方法的列表
*/
import java.util.List;
//公共类名
/**
* Xiugai2()类
* @author xinjie
*
*/
public class Xiugai2 {

//定义主方法
/**
* main()方法
* @param String[] args
* @throws Exception
* return 无
*/
public static void main(String[] args) throws Exception {

//定义变量
/* 注意:
* \
* 转义字符
*/
String s1 = "{\"firsName\":\"Brett\",\"lastName\":\"McLaughlin\",\"email\":\"aaaa\"}";

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\{", "");

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\}", "");

//将s1将一个字符串分割为子字符串，然后将结果作为字符串数组返回String[] a1
String[] a1 = s1.split(",");


//创建实例化对象
/* 注意:
* 将修改后的泛型String数组实例化给列表泛型的String数组
*/
List<String[]> arraylist = new ArrayList<String[]>();
//for循环
/* 注意:
* 每次取数组中一个元素，采取遍历方式
*/
for(String s : a1){

//定义变量
/* 注意:
* s将一个字符串分割为子字符串，然后将结果作为字符串数组返回参数遍历
* 赋值被String数组类的m
*/
String[] m = s.split(":");

//调用方法
arraylist.add(m);
}

//for循环
for(String[] m : arraylist){

//if语句
/* 注意:
* m数组的第一个等于email
*/
if(m[0].equals("\"email\"")){

//定义变量
/* 注意:
* m数组的第二行是bbbb
*/
m[1] = "bbbb";
}
}

//定义变量
/* 注意:
* 把[{定义进json
*/
String json = "[{";

//for循环
for(String[] m : arraylist){

//json等于json加上m的第一个数组加上":"加上m数组的第二个加上","
json += m[0] + ":" + m[1]+ ",";
}

//输出
System.out.println(json + "}]");
}
}




//引用包
/* 注意:
* 修改
*/
import java.util.ArrayList;

//引用包
/* 注意:
* 提供公共的执行操作方法的列表e
*/
import java.util.List;

//公共类名
/**
* Get()类
* @author xinjie
*
*/
public class Array {

//定义主方法
/**
* main()方法
* @param String args
* @throws Exception
* return 无
*/
public static void main(String[] args) throws Exception {

//定义变量
/* 注意:
* \
* 转义字符
*/
String s1 = "{\"firsName\":\"Brett\",\"lastName\":\"McLaughlin\",\"email\":\"aaaa\"}";

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\{", "");

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\}", "");

//将s1将一个字符串分割为子字符串，然后将结果作为字符串数组返回String[] a1
String[] a1 = s1.split(",");

//创建实例化对象
/* 注意:
* 将修改后的泛型String数组实例化给列表泛型的String数组
*/
List<String[]> arraylist = new ArrayList<String[]>();

//for循环
/* 注意:
* 每次取数组中一个元素，采取遍历方式
*/
for(String s : a1){

//定义变量
/* 注意:
* s将一个字符串分割为子字符串，然后将结果作为字符串数组返回参数遍历
* 赋值被String数组类的m
*/
String[] m = s.split(":");

//调用方法
arraylist.add(m);
}
 
//定义变量
/* 注意:
* 把
* "\"FileName\":\"cccc\""
* 定义到
* String fileName
*/
String fileName = "\"FileName\":\"cccc\"";
 
//调用方法
/* 注意:
* 将fileName将一个字符串分割为子字符串，然后将结果作为字符串数组增加arraylist
*/
arraylist.add(fileName.split(":"));


//定义变量
/* 注意:
* 把[{定义进json
*/
String json = "[{";

//for循环
for(String[] m : arraylist){

//json等于json加上m的第一个数组加上":"加上m数组的第二个加上","
json += m[0] + ":" + m[1]+ ",";
}

//输出
System.out.println(json + "}]");
}
}



//引用包
/* 注意:
* 修改
*/
import java.util.ArrayList;

//引用包
/* 注意:
* 提供公共的执行操作方法的列表e
*/
import java.util.List;

//公共类名
/**
* Get()类
* @author xinjie
*
*/
public class delete {

//定义主方法
/**
* main()方法
* @param String args
* @throws Exception
* return 无
*/
public static void main(String[] args) throws Exception {
 
//定义变量
/* 注意:
* \
* 转义字符
*/
String s1 = "{\"firsName\":\"Brett\",\"lastName\":\"McLaughlin\",\"email\":\"aaaa\"}";

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\{", "");

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
s1 = s1.replaceAll("\\}", "");

//将s1将一个字符串分割为子字符串，然后将结果作为字符串数组返回String[] a1
String[] a1 = s1.split(",");

//创建实例化对象
/* 注意:
* 将修改后的泛型String数组实例化给列表泛型的String数组
*/
List<String[]> arraylist = new ArrayList<String[]>();

//for循环
/* 注意:
* 每次取数组中一个元素，采取遍历方式
*/
for(String s : a1){

//定义变量
/* 注意:
* s将一个字符串分割为子字符串，然后将结果作为字符串数组返回参数遍历
* 赋值被String数组类的m
*/
String[] m = s.split(":");

//调用方法
arraylist.add(m);
}
 
//for循环
for(String[] m : arraylist){

//if语句
/* 注意:
* m数组的第一个等于email
*/
if(m[0].equals("\"email\"")){

//定义变量
/* 注意:
* m数组的第二行是没有
*/
m[1] = "";
}
}

//定义变量
/* 注意:
* 把[{定义进json
*/
String json = "[{";

//for循环
for(String[] m : arraylist){

//json等于json加上m的第一个数组加上":"加上m数组的第二个加上","
json += m[0] + ":" + m[1]+ ",";
}

//输出
System.out.println(json + "}]");
}
}



//引用包
/* 注意:
* 修改
*/
import java.util.ArrayList;

//引用包
/* 注意:
* 提供公共的执行操作方法的列表
*/
import java.util.List;

//公共类名
/**
* Dement()类
* @author xinjie
*
*/
public class Dsabs {

//定义主方法
/**
* main()方法
* @param String[] args
* @throws Exception
* return 无
*/
public static void main(String[] args) throws Exception {

//定义变量
/* 注意:
* \
* 转义字符
*/
String obj = "{\"firsName\":\"Brett\",\"lastName\":\"McLaughlin\",\"email\":\"aaaa\"}," +
"{\"firsName\":\"Brett\",\"lastName\":\"McLaughlin\",\"email\":\"bbbb\"}";

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
obj = obj.replaceAll("\\{", "");

//调用方法
/* 注意
* 写法将英文括号替换成其他字符
*/
obj = obj.replaceAll("\\}", "");
 
//将s1将一个字符串分割为子字符串，然后将结果作为字符串数组返回String[] a1
String[] a1 = obj.split(",");
 
//创建实例化对象
/* 注意:
* 将修改后的泛型String数组实例化给列表泛型的String数组
*/
List<String[]> arraylist = new ArrayList<String[]>();
 
//for循环
/* 注意:
* 每次取数组中一个元素，采取遍历方式
*/
for(String s : a1){
 
//定义变量
/* 注意:
* s将一个字符串分割为子字符串，然后将结果作为字符串数组返回参数遍历
* 赋值被String数组类的m
*/
String[] m = s.split(":");
 
//调用方法
arraylist.add(m);
}

//定义变量
int i = 0;

//for循环
for(String[] m : arraylist){

//if语句
if(m[1].equals("\"McLaughlin\"")){

//输出
System.out.println(arraylist.get(i+1)[0] + " "  + arraylist.get(i+1)[1] );
}
//i加1
i++;
}

}
}



今天的单词

switch case break