时间格式转换和四种数组

一、获取当前时间，转换字符串 和 字符串转换时间

    public static void main(String[] args) throws ParseException{
        String d="2018-06-28 19:20:56";
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(date));
        //时间转字符串用  .format
        Date date1=sdf.parse(d);
        //字符串转时间用 .parse
        System.out.println(date1);
    }

 public static void main(String[] args) throws ParseException{
          String time="20101125102503"; 
          //String类型的字符串
          SimpleDateFormat formatter1=new SimpleDateFormat("yyyy-HH-dd HH:mm:ss");
          //new一个时间格式对象
          SimpleDateFormat formatter2=new SimpleDateFormat("yyyyHHddHHmmss"); 
          //new一个时间格式对象
          time=formatter1.format(formatter2.parse(time)); 
          //formatter2对象的方法把parse(time)转换成formatter2样式的时间格式
          //formatter1对象的方法format()，把formatter2.parse(time)时间类型，转换成字符串类型的格式
          System.out.println(time); 
        }   

二、集合数组 （分为两类：类一、存放单值数据，类二、存放键值对数据）

存放单值类数组： 1. 数组， 2. ArrayList， 3. HashSet

1.数组 （属性：固定大小、单值、有序、可重复）

• 创建：数据类型[] 变量名=new 数据类型[需要存放数据的个数]
• 赋值：变量名[下标]=值
• 取值：变量名[下标]
  注意事项：存数组的时候，不能超过实际设置的下标的值！不然程序执行的时候会报错误

    String[] la = new String[3];
        // 定义一个数组，然后取数组下标进行赋值
        la[0] = "aaa";
        la[1] = "bbb";
        la[2] = "ccc";
        la[3]="ddd";//这是一个错误的赋值，不能赋值超过数组容器的数量

        String[] lala = { "a001", "b001", "c001" };
        // 定义一个String数组，并直接赋值
        
        Integer[] ss = new Integer[2];
        // 定义一个整数类型的数组，整数类型用integer而不是用int
        ss[0] = 1;
        ss[1] = 2;

        for (int i = 0; i < la.length; i++) {
            System.out.println(la[i]);
        //for循环打印出数组中存的所有的值，如果没有存，默认打印0
        }
        int a = 0;
        while (a < la.length) {
            System.out.println("while循环：" + la[a]);
            a++;
        }

2. ArrayList （属性：不固定大小、单值、有序、可重复）

• 创建：List<泛型>] 变量名=new ArrayList<泛型>();
• 赋值：变量名.add(对应的数组类型);
• 取值：变量名.get(数据位置);

        List arr = new ArrayList();
        //动态大小、有序、单值，用list数组，ArrayList向上转型为list
        arr.add("这是一个list数组");//.add()；存值
        arr.add("这是第二个list");
        arr.add("这是第三个list");
        for (int b = 0; b < arr.size(); b++) {
            //除了数组arrer用length，全用size()获取数组中存的的数据的个数
            System.out.println("这是一个list数组的for循环：" + arr.get(b));
        }
        int a = 0;
        while (a < arr.size()) {
            System.out.println("这是list的while循环" + arr.get(a));
            a++;
        }

3. Set（属性：不固定大小、单值、无序、值去重）

• 创建：Set<泛型>] 变量名=new HashSet<泛型>();
• 赋值：变量名.add(对应的数组类型);
• 取值：因为Set数组是无序的，所以要用foreach遍历出来，或者用数组自带的排序方法 .iterator();，给自身进行排序，然后用排序后的.hasNext方法，进行取值

Set Str = new HashSet();
        // new一个Set类型的存储空间
        Str.add("SetNo1");
        Str.add("SetNo2");
        Str.add("SetNo3");
        Iterator IteStr = Str.iterator();
        // 无序的数组做取数据之前，要给无序的数组排序，每个数组都有自己的排序方法Iterator()
        // 先写数组本身的排序方法Str.iterator()，鼠标放在上面即可看见返回的数据类型为:Iterator

        while (IteStr.hasNext()) {
            // 因为数组中存的值的个数不固定，只能用while循环和foreach遍历
            // 排序后的数据，自带hasNext方法，意思是：是否有下一个，返回结果为true则执行，取值为，naxt 下一个
            String cc = IteStr.next();
            if (cc.equalsIgnoreCase("setno3")) {
                // if(cc.contains("SetNo3"))，包含的意思，
                // equals:相等的意思 
                //equals() 大小写敏感，equalsIgnoreCase，大小写不敏感
                System.out.println(cc);
                break;
            }

        }
        for (String st : Str) {
        //foreach 遍历
            if (st.contains("SetNo2")) {
                // 只有全部的数据都要取，才用for遍历
                System.out.println(st);
                break;
            }
        }

泛型：广泛的类型！

定义一个数组，我们不光要在内存中划分存储的空间，还要确定这个数组存的什么类型的数据，虽然不加泛型可以存各种类型的值，但是取数据的时候怎么办？

---

存放键值对类数组： 1. Javabean 2. HashMap

1. javabean （属性：键值对，固定大小，引用自写类属性、方法）

• 创建：方法名 变量名=new 方法名();
• 赋值：方法名.属性名字=属性名对应的类型的值 or 方法名.set属性名(属性名对应的值);
• 取值：方法名.get(属性名);

    //这是自写的类，封装了属性和属性的set()、 get()方法
    public String Name ;
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int age;
    @Override
    public String toString() {
        return "Person [Name=" + Name + ", age=" + age + ", getClass()="
                + getClass() + ", hashCode()=" + hashCode() + ", toString()="
                + super.toString() + "]";
    }

这是Javabean写法

    Person per = new Person();
        // 这是一个Javabean数组，把自己定义的类给new出来，使用里面的属性和方法

        per.age = 18;
        per.setName("顾虹雁");
        // 两种方法给new出来属性赋值
        
        System.out.println(per.getAge()+"  这是Javabean的get取值");
        System.out.println("这是我女神的名字："+per.getName());
        //age  和  name 的get方法，分别取值打印
        
        String Result = per.toString();
        // 调用Person类下的toString方法，把赋的值打印出来
        System.out.println("这是一个javabean:" + Result);

2. HashMap（属性：动态大小，键值对，key去重,无序存放数据）

• 创建：Map map=new HashMap();
• 赋值：变量名.put(key,value);
• 取值：因为HashMap数组是无序的，所以要用foreach遍历出来，或者用数组自带的排序方法 .iterator();，给自身进行排序，然后用排序后的.hasNext方法，进行取值

   
        Map map = new HashMap();
        // 增加数据
        map.put("name", "guoya");
        map.put("age", "1");
        map.put("addr", "上海浦江镇");

        // 修改数据
        map.put("addr", "上海市闵行区浦江镇");

        // 取单个：
        String name = map.get("name");
        String age = map.get("age");

        // 通过entrySet()方法将map集合中的映射关系取出（这个关系就是Map.Entry类型）
        Set> mapentry = map.entrySet();

        // 将关系集合entrySet进行迭代，存放到迭代器中
        Iterator> it = mapentry.iterator();

        // 简写HashMap调用迭代器的方法
        // Iterator> iterator =
        // map.entrySet().iterator();
        while (it.hasNext()) {
            // 获取Map.Entry关系对象item
            Map.Entry item = it.next();

            // 通过关系对象获取key
            String key = item.getKey();

            // 通过关系对象获取value
            String value = item.getValue();
        }