2021-07-26

Date类
Date date=new Date();
System.out.println(date.getTime());//1970 date不支持国际化
Calendar类
Calendar c=Calendar.getInstance();//单例设计
Date d=c.getTime();//date与calendar可以相互转换
c.setTime(d);
System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH+1))+"月"+c.get(Calendar.DATE)+"日"+c.get(Calendar.HOUR)+c.get(Calendar.MINUTE)+"分"+c.get(Calendar.SECOND)+"秒");

SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日kk小时mm分钟ss秒 E");//格式化
//SimpleDateFormat sdf=new SimpleDateFormat("yyyy//MM//dd kk:mm:ss秒 E");//格式化
String string= sdf.format(d);
String string1= sdf.format(c.getTime());

System.out.println(string);

System.out.println(c.get(Calendar.HOUR));

SimpleDateFormat sdf1=new SimpleDateFormat("yyyy//MM//dd kk:mm:ss E");
String string3="10:12:23 1999/3/24";
try {
    Date date3=sdf.parse(string3);
    System.out.println(date3);
} catch (ParseException e) {
    e.printStackTrace();
    //字符格式化
    int num=25421;
    NumberFormat numberFormat=new DecimalFormat("##,###,00");
    System.out.println(numberFormat.format(num));
    // TODO: handle exception
}

Date date=new Date();
date.setYear(99);//用1999-1900年
date.setMonth(1);
date.setDate(2);
System.out.println(date);
Calendar calendar=Calendar.getInstance();
calendar.set(calendar.YEAR, 1999);//这个就没有偏移量了
calendar.set(calendar.MONTH, 1);
System.out.println(calendar.get(Calendar.YEAR));

StringBuffer 与String
StringBuffer stringBuffer=new StringBuffer("abc");
System.out.println(stringBuffer);
String str="abc";
str=str+"123";
stringBuffer.append("123");//拼接字符串
System.out.println(stringBuffer);
System.out.println(stringBuffer.reverse());//逆序排列
//String 和StringBuffer区别:StringBuffer动态缓存，可以对字符串进行修改，string不能
//string 可以stringbuffer相互转换
String string=stringBuffer.toString();
StringBuffer stringBuffer1=new StringBuffer(string);
    }

集合-高级
把多个数据存起来的一个类，用集合类表示数据的存储，用集合类弥补数组的缺陷（长度固定、类型单一）
集合中只能存放对象不能存放基本数据类型

集合和数组有什么区别：
数组是容器，它的长度是固定的，不会自动扩充，数组中既可以存放基本数据类型也能存放引用数据类型的引用。
集合也是一种容器，它的长度是可变的，集合中只能存放引用数据类型的引用。
集合有3类：
set集是存放无序的（不可重复）
List有序的含有索引（可以重复）
Map映射，键值对，

层次结构的根接口
Collection接口
子接口set：无序集合，不可重复
set接口的实现类：HashSet
子接口List：有序集合允许重复。
List接口的实现类：ArrayList、LinkedList

List例1
    Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        Student s4 = new Student();
        Student s5 = s2;
        // TODO Auto-generated method stub
        List list = new ArrayList();// 构建集合对象
        list.add("aaa");// 往末尾添加数据
        list.set(0, "111");//替换
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
//        list.add(s1);
//        list.add(s2);
//        list.add(s3);
//        list.add(s4);
        System.out.println(list.size());
//        list.remove(2);//消除索引位置的数据，只删除1条
//        for (int i = 0; i < list.size(); i++) {
//            String string = (String) list.get(i);
            Student stu = (Student) list.get(i);
            System.out.println(stu);
//            System.out.println(string);
//        }
        
        list.add(2, "123");
        // list.clear();
        System.out.println(list.contains("ddd"));
        System.out.println(list.contains(s5));//引用数据类型，地址相同
        
        for(Object o:list)
        {
            System.out.println(o);
        }
    }

结果
4
true
false
111
bbb
123
ccc
ddd
用LinkedList来模仿链表，头尾相接
private LinkedList linkedList=new LinkedList();
    public LinkedList getLinkedList() {
        return linkedList;
    }
    public void setLinkedList(LinkedList linkedList) {
        this.linkedList = linkedList;
    }
    public void addLast(Object obj){
        linkedList.addLast(obj);
    }
    public Object getLast(){
        Object object=linkedList.getLast();
        linkedList.removeLast();
        return object;
    }

test里
        StackLink stackLink=new StackLink();
        stackLink.addLast("aaa");
        stackLink.addLast("bbb");
        stackLink.addLast("ccc");
        stackLink.addLast("ddd");
        
        
        stackLink.getLast();
        stackLink.getLast();
        for(Object obj:stackLink.getLinkedList())
        {
            System.out.println(obj);
            
        }

set特点（无序不重复）
//        Set set = new HashSet();//无序的set集合
        Set set = new TreeSet();//有序的set集合
        set.add("aaa");
        set.add("bbbb");
        set.add("cccc");
        set.add("ddd");
        set.add("eee");
        //增强for循环方式，但是顺序是无序的
//        for(Object obj:set){
//            System.out.println(obj);
//        }
        //迭代器方式遍历
        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            Object object=iterator.next();
            System.out.println(object);
        }

Map：key-value
hashmap

    Map map = new HashMap();
        map.put("小张", "张三");
        map.put("小张", "张三123");
        map.put("小李", "李四");
        map.put("小王", "王五");
        System.out.println(map);
        Object object=map.get("小王");
        String string=(String)object;
        System.out.println(string);
        
        Set set=map.keySet();//获取键的集合
        
        map.remove("小王");//删除的是键值对

泛型：规范初始存放的类型
    List<String> list=new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        for (String s:list) {
            System.out.println(s);
        }
        Set<String> set=new HashSet<String>();
        Map<String, Student> map=new HashMap<String, Student>();
        map.put("小张", new Student());
    String string=list.get(1);

包装类/封装类
package com.neusoft.test6;

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

import org.omg.CORBA.LongHolder;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
            List<Integer> list=new ArrayList<Integer>();
//            Integer i1=new Integer(1);
//            Integer i2=new Integer(2);
//            Integer i3=new Integer(3);
//            Integer i4=new Integer(4);
//            Integer i5=new Integer(5);
//            list.add(i1);
//            list.add(i2);
//            list.add(i3);
//            list.add(i4);
//            list.add(i5);
            
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
//            for(Integer i:list){
//            System.out.println(i.intValue());    
//            }
            for(Integer i:list){
                System.out.println(i);    
                }
            //包装类、封装类：将8个基本数据类型对应做成的引用数据类型
            
//            int,char 另外6个都是首字母大写
//            double Double;
//            float Float;
//            boolean Boolean;
//            byte Byte;
//            short Short;
//            long Long;
//            char Character;
//            int Integer;
//            int num=100;
//            Integer integer=new Integer(100);
//            //他们俩是等价的，只不过表现形式不同，一种是基本数据类型，一种是引用数据类型
//            list.add(integer);
//            int i=integer.intValue();
//            
//            double d=3.14;
//            Double double1=new Double(d);//装箱
            
//            double d1=double1.doubleValue();//拆箱

            Double double2=new Double(3.14);
            double d2=double2;//自动拆箱
            
            //基本与引用类型的相互转换
//            
            Integer num=100;//自动封装，装箱
            
            String string="123";
            Integer i=Integer.parseInt(string);//将字符串转换为整形
            System.out.println(i+100);
            
            int num1=123;
            Integer i2=num1;
            System.out.println(i2.toString());//将整形以字符串类型转换
            System.out.println(123+"");//同上
                        
    }

}

简单叙述一下 Arraylist扩容 与 hashmap 扩容机制 ？
 Arraylist扩容是为1.5倍