包装类、异常、集合知识回顾

2. 常用类
1）Math类（封装了数学相关的方法），Random类（产生随机值）
2）String类：equals方法比较值内容一般用“abc”.equals 常量放在前面避免空指针异常
a）字符串的两种定义方法和区别
b）StringBuffer类，是线程安全的，StringBuilder类，是线程不安全的

    public static void main(String[] args) {
        int num=5;//蓝色是保留字,不能命名
        String str="zhang";//类
        String str1="zhang";//定义的是字符串常量
        String s=new String("s");
        String s1=new String("s");//栈堆对象
        System.out.println(s==s1);
        System.out.println(str==str1);
        System.out.println(s.equals(s1));//比较值,内容
       // System.out.println(s.equals("list"));
        System.out.println("list".equals(s));//推荐这种避免空指针异常

        String ss="";
        //生成随机的验证码，由26个大写字母，26个小写字母，10个数字，每个验证码4位
        for(char c='A';c<='Z';c++){
            ss+=c;
        }
        for(char c='a';c<='z';c++){
            ss+=c;
        } for(char c='0';c<='9';c++){
            ss+=c;
        }
        System.out.println(ss);
        System.out.println("=================");

        StringBuffer buffer=new StringBuffer();
        for(char c='A';c<='Z';c++){
            buffer.append(c);//追加
        }
        for(char c='a';c<='z';c++){
            buffer.append(c);
        } for(char c='0';c<='9';c++){
            buffer.append(c);
        }
        System.out.println(buffer.toString());//显示字符串
        String code="";
        Random r=new Random();
        int index;
        for (int i=0;i<4;i++){
            index=r.nextInt(62);//0-61
            code+=buffer.toString().charAt(index);
        }
        System.out.println(code);
    }
}

3）时间日期类
a）Date
b）Calendar

    public static void main(String[] args) {
        Calendar ca = Calendar.getInstance();//不能用new会实现所有抽象方法，getInstance获取实例
        System.out.println(ca.get(Calendar.YEAR));
        System.out.println(ca.get(Calendar.MONTH)+1);
        System.out.println(ca.get(Calendar.HOUR));
        
        GregorianCalendar gregorianCalendar=new GregorianCalendar();//calendar的子类
        System.out.println(gregorianCalendar.get(Calendar.HOUR_OF_DAY));
    }
}

c）SimpleDateFormat（Java8的新特性里LocalDateTime类，用来替换SimpleDateFormat：SimpleDateFormat线程不安全，LocalDateTime线程安全）
d）System类中一个方法

//        System.out.println(new Date());
//        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        String time =format.format(new Date());
//        System.out.println(System.currentTimeMillis());//毫秒数
//        String time1=format.format(System.currentTimeMillis());

//记录用户两次输入之间的间隔
Scanner s=new Scanner(System.in);
String str1=s.next();
long time2=System.currentTimeMillis();
String str2=s.next();
long time3=System.currentTimeMillis();
long time4=time3-time2;
SimpleDateFormat sdf=new SimpleDateFormat("mm:ss");
System.out.println(sdf.format(time4));

4）包装类：四类八种基础数据类型，把他们封装了对象。如Integer Character

每个包装类里，都有一个parse开头的方法，作用是将字符串转化成对应的基础数据类型

//        Integer a=new Integer(5);//a是对象  
//        System.out.println(Integer.parseInt("123"));

3.异常

Throwable
| |
Error Exception
1）.异常是在程序运行时出现的错误
2）异常的后果很严重，立即停止程序的运行
3）异常：强制处理的，不强制要求处理的
4）如何去处理异常：处理异常之后，程序就不会被强制结束。
a）用try-catch-finally包裹 try可以多个catch子类异常写前面，父类写后面

public static void main(String[] args) {
    //通过循环输入5个学生的信息，包括姓名年龄班级和成绩
    //将其存储到数组里
    Scanner sc=new Scanner(System.in);
    Student []s=new Student[2];

   // try {
    for (int i=0;i<s.length;i++){

        Student stu=new Student();
        stu.setName(sc.next());
        System.out.println("输入年龄");
        while (true) {
            int t = CheckInput.parseStringToInt(sc.next());
            if (t == -1) {
                System.out.println("输入整数");
            } else {
                break;
            }
        }
        System.out.println("输入班级");
        stu.setClazz(sc.next());
        stu.setScore(sc.nextInt());
        s[i]=stu;

public class CheckInput {
    //规避控制台输入数据和读取类型不匹配的异常
    public static int parseStringToInt(String str) {
        int num = -1;
        try {
            num = Integer.parseInt(str);
        } catch (NumberFormatException e) {

        }
        return num;
    }
}

b）用throws声明抛出异常

public class Check {
    //声明异常是必须捕获的，throws方法声明位置，throw方法体里，执行抛出异常的动作

    public double div(int a, int b) throws Exception{//throws Exception  throws必须处理异常
        if (b != 0) {
            return a / b;
        }else {
            throw new Exception();
        }

//            Check c=new Check();
//            try {
//                System.out.println(c.div(1,2));
//            } catch (Exception e) {
//               //e.printStackTrace();
//                System.out.println("除数不能为0");
//            }

4.集合
1）集合和数组的区别
数组既可以放基础数据类型，也可以放对象类型，但是集合只能放对象，不能放基础数据类型
数组是定长的，而集合是可以改变长度的，而且可以随时添加删除元素
集合要和泛型结合

Collection的子类的通用方法：size获取元素个数，get获取当前索引的元素，add添加元素，remove删除元素，clear清空集合
2）List接口，不能直接实例化对象，要用已知实现的子类
ArrayList：基于数据存储的，是连续的空间，所有查询效率高，而添加删除效率低
LinkedList：基于链表存储的，不连续的空间，所以查询效率低，而添加删除效率高

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Scanner s=new Scanner(System.in);
        String t;
        while(true)
        {
            t=s.next();
            if("-1".equals(t)){
            break;
        }else
        {
           list.add(t);
        }
        }
        System.out.println(list.size());
    }
}

public class DemoStudent {
    public static void main(String[] args) {
        List<Student>list=new ArrayList<>();
        Scanner s=new Scanner(System.in);
//        Student student=new Student("z",1,2);
//        list.add(student);
        while (true){
            System.out.println("输入信息，输入0结束");
            if("0".equals(s.next())){//字符串
                break;
            }else {
                Student student=new Student(s.next(),s.nextInt(),s.nextInt());
                list.add(student);
            }
        }
        //遍历
//        for (int i=0;i<list.size();i++){
//            System.out.println(list.get(i));
//        }
//        for (Student stu:list){
//            System.out.println(stu);
//        }
        //返回iterator迭代器
        Iterator iterator= list.iterator();
        while (iterator.hasNext()){//是否有元素可以迭代
            System.out.println(iterator.next());//返回下一个元素  Object类型
        }
    }
}

3）Set：如果确保set中，不存在属性相同的元素，需要重写两个方法，一个HashCode（属性比较）方法，一个是equals方法，都继承于object类
判断两个元素是否相同，先判断hashCode是否相同，如果相同，在判断equals方法
如果两个对象equals，Java运行环境会认为他们的hashcode一定相同
如果两个对象不equals，Java会认为他们的hashCode可能相等
如果两个对象的hashcode相等，他们不一定equals
如果两个对象的hashcode不相等，他们的一定不equals

改变值，hashcode不同，但是一样的引用会被覆盖

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return price == car.price &&
                Objects.equals(brand, car.brand) &&
                Objects.equals(Color, car.Color);
    }

    @Override
    public int hashCode() {
        return Objects.hash(brand, Color, price);
    }
}

public class DemoSet {
    public static void main(String[] args) {
        Set<Car>set=new HashSet<>();
        Car car=new Car("x","s",1);
        Car car1=new Car("x","s",2);
        set.add(car);
        set.add(car1);
        System.out.println(car1.hashCode());
//        car1.setBrand("s");
//        set.add(car1);
        set.add(car1);
        System.out.println(car1.hashCode());
        System.out.println(car.hashCode());
//        for (Car car2:set){
//            System.out.println(car2);
//        }
        Iterator iterator= set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

4）Map：键值对，k表示key，v表示value，不能存在同一个key，如果多次为同一个key放入值，后面的值会把前面的值替换

    public static void main(String[] args) {
        Map<String,Object>map=new HashMap<>();
        map.put("name","zhang");//put添加
        map.put("num","001");
        map.put("score",90);
        map.put("score",99);//如果多次为同一个key放入值，后面的值会把前面的值替换


        System.out.println(map.get("name"));//取值 key
        for (String key:map.keySet()){//遍历keyset  返回set集合
            System.out.println("key="+key+","+"value="+map.get(key));//get找到key对应的值
        }

        List<Map<String,Object>> list=new ArrayList<>();
        Map<String,Object>map1=new HashMap<>();
        map1.put("name","zhang");
        map1.put("num","001");
        map1.put("score",90);
        list.add(map1);
        map1=new HashMap<>();//重新实例化
        map1.put("name","yang");
        map1.put("num","002");
        map1.put("score",80);
        list.add(map1);
       //map不能用iterator遍历
        for(Map<String,Object> m:list){
            for (String key:m.keySet()){
                System.out.println(key+","+m.get(key));
            }
        }
         // Map<String,Map<String,Object>> map=new HashMap<>();

    }
}

5）三种集合的区别：List和Set有相同的父接口Celloction，Map不是Collection的子类
List和Set的区别：Set不允许出现重复元素（重写hashCode和equals），不保证集合中元素的顺序，是无序的，允许放入null的元素，但是最多只能有一个null元素
List允许重复元素，有序，不能放null

posted @ 2021-03-11 17:26 YangYuJia 阅读(98) 评论(0) 收藏举报

刷新页面返回顶部

YangYuJia

包装类、异常、集合知识回顾

公告