Java基础二 – 小飞侠

package chapter02;

public class Object {
    public static void main(String[] args) {
        // TODO 常见类和对象-对象
        Person p = new Person();
        String s = p.toString();
        int i = p.hashCode();

        //chapter02.Person@511d50c0 包名+哈希code值（内存地址)
        System.out.println(p);
        // 1360875712 十进制
        System.out.println(i);

    }
}
class Person {
    String name = "lisa";
    @Override
    public String toString() {
        return "Person["+name+"]";
        // Person[lisa]
    }
}
class Son extends Person {

}

1.2 数组 Array

数组声明：类型 [ ] 名 = new 类型[索引n ]；索引表示数组有n个对象
添加和访问数据时，不能超过指定范围（0~length-1）
如果给相同的索引添加值，会覆盖原先的值，等同于修改数据

package chapter02;

public class Array {
    public static void main(String[] args) {
        // TODO 数组Array
        //数组声明:类型[] 名 =  new 类型[];
        User[] users = new User[3];
        //访问数组
        for (int i = 0; i<users.length;i++){
            users[i] = new User();
        }
        for (int i = 0; i<users.length;i++){
            users[i].test();
        }
    }
}
class User {
    public void test() {
        System.out.println("test");
    }
}

1.3 二维数组

package chapter02;

public class Array02 {
    public static void main(String[] args) {
        // TODO 二维数组
//        String[][] names ={{"a","b"},{"a","b"},{"a","b"}};
        String[][] names = new String[3][3];
        names[0][1]="lisa";
        //查看所以的数组
        for (int row =0; row < 3; row++){
            for (int col =0; col < 3; col++){
                System.out.print(names[row][col]+"   ");
            }
            System.out.println();
        }
    }
}

1.4冒泡排序法

1.5选择排序法

1.6 二分查找法

package chapter02;

public class TwoPartSeachaer {
    public static void main(String[] args) {
        // TODO 二分查找
        int[] nums ={1,2,3,4,5,6};
        
        int target = 5;
        int start = 0;
        int end = nums.length-1;
        int middle = 0;
        while (start <= end) {
            middle = (start + end) / 2;
            if (nums[middle]>target){
                end = middle -1;
            }else if(nums[middle] < target){
                start = middle +1;
            }else {
                break;
            }
        }
        System.out.println("数字位置："+middle);
    }
}

1.7 字符串

字符串的拼接:

+ 符号，符号后面的当做字符串看
.concat()

字符串的比较

A.equals(B)
A.equalsIgnoreCase(B) ,忽略大小写
A.compareTo(B) ,如果A大于B，返回证书，A小于B返回负数，相等返回0
A.compareToIgnoreCase(C)，忽略大小写

字符串的截取

s.substring（begininex,endindex）:传2个参数，第一个参数包含，第二个参数不包含，传一个参数，从参数截取都最后
s.split()：对字符串进行分解，拆分为几部分
trim（）：去字符串的收尾空格

字符串的替换

s.replace(target,replacement)
s.replaceAll(target,replacement)，按照一定的规则进行替换

字符串的大小写转换

toLowerCase（）：转小写
toUpperCase（）:转大写

字符串的查找

toCharArray()：返回一个数组
getBytes()：返回byte 数组
charAt()：传递索引值定位字符串位置
indexof()：获取字符串第一次出现的位置
lastindexof()：获取字符串最后一次出现的位置
contains()：是否包含字符串，返回布尔值
startsWith()：判断开头的字符，返回布尔值
endsWith()：判断结尾的字符，返回布尔值
isEmpty()：判断是否为空字符，注意空格不是空字符，是一个特殊的字符

StringBuilder 构建字符串

当频繁拼接字符串时使用，提供append增、delete删、replace改、insert查的方法

语法：StringBuilder s = new StringBuilder(“a”);

package chapter02;

public class StringS {
    public static void main(StringS[] args) {
        // TODO 字符串
        // 拼接
        String A = "A" +"B";
        String B ="A" + 11;
        String C = 1+ 2 + "C" +3; //3C3
        System.out.println(A.concat(C));

        //比较
        A.equals(B);
        A.equalsIgnoreCase(B); //忽略大小写
        A.compareTo(B);
        A.compareToIgnoreCase(C);//忽略大小写

        // 截取
        String s = "hello";
        System.out.println(s.substring(2));
        s.split("e"); // h llo

        // 替换
        String say = "welcome to China";
        System.out.println(say.replace("China","American"));
        //.replaceAll() 按照一定的规则进行替换
        say.replaceAll("to|China","American"); // welcome American American

        // 大小写转换
        String word = "ABC";
        word.toLowerCase(); //小写
        word.toUpperCase(); //大写

        // 字符串的查找
        String hello = "hello world";
        char[] chars = hello.toCharArray();
        byte[] bytes = hello.getBytes();
        hello.charAt(1);//e
        hello.

    }
}

1.8 包装类

常见的类和对象：byte\short\int\long\float\double\boolean

package chapter02;

public class packageClass {
    //TODO 包装类
    int i = 10;
    // 将基本的数据类型转换为包装类型
    Integer i1 = i;
    // 拆箱
    int i2 = i1.intValue();
    // 自动拆箱
    int i3 = i1;
}

1.9 日期类

日期类：Date

y(Y): 年，yyyy m(M): MM月份，mm分钟
d(D): dd:一个月中的日期，DD一年中的日期
h(H): hh是十二进制，HH是二十四进制
s(S): s秒，ss毫秒
获取时间戳：注d是当前时间，d.getTime()
根据时间戳构建日期对象d.setTime(System.currentTimeMillis());

package chapter02;

import java.text.SimpleDateFormat;
import java.util.Date;

public class dateClass {
    public static void main(String[] args) throws Exception{
        //TODO Date日期类和 Calender日历类
        Date d = new Date();
        System.out.println(d); //获取当前时间 Tue Nov 29 23:45:14 CST 2022
        // java 格式化日期
        // y(Y): 年，yyyy
        // m(M): MM月份，mm分钟
        // d(D): dd:一个月中的日期，DD一年中的日期
        // h(H): hh是十二进制，HH是二十四进制
        // s(S): s秒，ss毫秒

        // Date->String
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:ss.SSSS");
        String s = sdf.format(d);
        System.out.println(s); //2022-11-29 23:14.0318

        //String -> Date
        String dates = "2020-02-23";
        Date parse =  sdf.parse(dates);
        System.out.println(parse);

        //根据时间戳构建日期对象
        d.setTime(System.currentTimeMillis());
        // 获取时间戳
        d.getTime();
        System.out.println(d.getTime()); //1669737825270
    }
}

日历类：Calender

package chapter02;

import java.util.Calendar;

public class Calender {
    public static void main(String[] args) throws Exception{
        // TODO 日历类
        Calendar c = Calendar.getInstance();
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONDAY));
        System.out.println(c.get(Calendar.DATE));
        
        c.add(Calendar.YEAR,-1); // 年份减一
    }
}

1.10 工具类

工具类不创建对象才能使用，可以直接使用类中的属性和方法，一般称为静态的
工具类对外提供的属性和方法都应该是公共的
为了开发方便，应该尽量提供丰富的方法和属性
生成随机字符串：UUID.randomUUID().toString()

package chapter02;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.UUID;

public class Object_utils extends Exception{
    public static void main(String[] args) {
        // TODO 工具类
        System.out.println(StringUtils.isEmpty("hjsaj"));
        System.out.println(StringUtils.isEmpty("   "));
        System.out.println(StringUtils.isNotEmpty("   "));
        System.out.println(StringUtils.getOnlyNum());
        System.out.println(StringUtils.getOnlyNum("hjshsajhakd",6));
        // 装换字符串
    }
}
class StringUtils {
    // todo 非空判断
    public static boolean isEmpty(String str) {
        // 如果为null、空字符串、空格都是为空
        if (str == null || str.trim().equals("")){
            return true;
        }
        return false;
    }
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    // todo 生成随机字符串
    // 随机字符串
    public static String getOnlyNum() {
        return UUID.randomUUID().toString();
    }
    //根据指定范围生成随机数
    public static String getOnlyNum(String from,int todo) {
        if ( todo < 1){
            return " ";
        }else {
            char [] chars = from.toCharArray();
            StringBuilder str = new StringBuilder();
            for (int i = 0; i < todo; i++) {
                Random n = new Random();
                int num = n.nextInt(chars.length);
                char c = chars[num];
                str.append(c);
            }
            return str.toString();

        }
    }
    //todo 转换字符串 HSA1312 => str => UTF-8
    // var快捷键自动补全
    public static String transform(String source ,String encode, String from) throws Exception{
        byte[] bytes = source.getBytes(from);
        return new String(bytes,encode);
    }
    public static Date parse(String data, String format) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.parse(data);
    }
}

1.11 比较

基本数据类型：==比较的是看数值是否相等，不看数据类型
引用数据类型： ==比较的是变量的内存地址
str.equals(str2)：一般用于字符串比较
包装类：比较不要用==，要用equals

2. 异常

2.1介绍

类型装换错误
递归没有跳出逻辑的错误：StackOverFlowError
访问一个为空对象的成员方法：空指针错误，java.long.NullPointerException

异常分为两大类

运行期异常：通过代码可以恢复正常逻辑执行的异常，RuntimeException
编译期异常：不可通过代码可以恢复正常逻辑执行的异常，Exception

2.2 基础语法

捕抓多个异常的时候，先捕抓范围小的，再捕抓范围大的

package chapter03_Exception;

public class Java_Exception {
    public static void main(String[] args) {
        // TODO 异常
        //语法
        int i = 0;
        int j = 0;
         //Exception in thread "main" java.lang.ArithmeticException: / by zero
        //at chapter03_Exception.Java_Exception.main(Java_Exception.java:9)

        try {
            j = 10/i;
        } catch (ArithmeticException e) {
            // e.getMessage(); //输出错误信息。
            // e.getCause(); 可抛出事件的原因，如果原因不存在或未知，则返回null
            // e.printStackTrace();打印错误位置和原因 代码规范 少用
            //解决方案
            i = 10;
            j = 10/i;
        } finally {
            System.out.println("最终执行的代码");
        }
        System.out.println(j);

    }
      /*  try {
            // 可能会出现异常的代码
            //如果出现异常，那么JVM就会将异常进行封装，形成具体的异常类

        } catch (抛出异常对象 对象引用) {
            异常解决方案
        } finally {
            最后执行的代码逻辑
        }
    }*/
}

2.3 常见异常

package chapter03_Exception;

public class Ofter {
    public static void main(String[] args) {
        // TODO常见的异常
        //1. 除数为0的算数异常： java.lang.ArithmeticException 运行期异常

        // 2 空指针异常 java.lang.NullPointerException
        // 调用了一个为空对象的成员属性和成员方法
        User u = null;
        if ( u != null){
            System.out.println(u.toString());
        }

        // 3. 数组索引越界异常:ArrayIndexOutOfBoundsException
        String[] names = new String[1];
        names[0] = "rose";
        // names[1] = "lisa";

        // 4. 字符串索引越界异常
        // StringIndexOutOfBoundsException
        String S = "ABC";
//        S.substring(4);

        // 5. 格式化错误
        //NumberFormatException
        String st = "s212";
//        Integer I = Integer.parseInt(st);

        // 6. 类型转换错误 ClassCastException
        Object obj = new User();
//        Test t = (Test)obj;


    }
}
class  User {

}
class Test {

}

异常转换：如果方法会出现异常，需要声明一下，需要用到关键字 throws

3. 集合

3.1 介绍

集合是一个容器，提供完整的集合框架
当容纳个数不确定时，不适合用数组
使用情景：对有不确定关系的数据进行相同的逻辑处理的场合

根据数据的不同，集合分2大体系

单一数据体系：Cellection接口定义了相关的规则
成对的数据体系：Map接口，2个数据有关系，第一个数据关联到第二数据，称键值对数据

3.2 常用的接口和类

Collection 接口

List：按照插入顺序保存，数据可重复，ArrayList，LinkedList
Set：无序保存，不可重复，HashSet
Queue：队列，ArrayBlockingQueue

Map 接口

具体实现类：HashMap、Hashtable

3.3 ArrayList 基本操作

按顺序存储，可重复

创建 new ArrayList()
新增 add(index,val)
查询 get(index)
修改 set(index,val)
删除 remove(index)

package chapter04_List;

import java.util.ArrayList;

public class one {
    public static void main(String[] args) {
        // TODO ArrayList实现类
        //无构造参数,底层数组为空
        ArrayList list = new ArrayList();
        //构造函数需要传递一个int类型的参数，用于设定底层数组长度
        //构造函数需要传递一个collection集合类型的值，用于其他集合的数据放置在当前集合中
        // TODO 打印集合对象
        System.out.println(list);

        //TODO 增加数据add;如果没数据，默认开辟一个10的数组
        list.add("lisa");

        //TODO 访问数据
        System.out.println(list.size());
        System.out.println(list.get(1));
        //遍历数据
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }

        //TODO 修改数据
        // 传递两个参数，第一个是index，第二个是修改的值，方法会返回更新前的值
        Object oldval=  list.set(1,"rose");
        System.out.println(oldval);

        // TODO 删除数据,remove(index),返回删除的值
        Objecte removeval = list.remove(1);

    }
}

3.4 ArrayList 的常用方法

新增 add(index,val)
新增 addAll() 追加一个集合
清空集合数据 clear()
判断集合中是否包含数据，返回布尔值，contains()
indexOf() 返回元素索引值，如果不存在返回-1，如果存在相同的值，返回第一个的索引值
toArray 转集合为数组类型
clone() 克隆集合

3.5 LinkedList 集合

是一种双链表集合
新增 add() / addFirst() / addLast()
获取 getFirst() / getLast() / get(index)
修改 set()
删除 remove()

3.6 LinkedList 常用方法

新增 add(index,val)
新增 addAll() 追加一个集合
清空集合数据 clear()
判断集合中是否包含数据，返回布尔值，contains()
indexOf() 返回元素索引值，如果不存在返回-1，如果存在相同的值，返回第一个的索引值
toArray 转集合为数组类型
clone() 克隆集合
element() 获取第一个数据
push() 追加数据
pop() 删除数据

3.7 集合泛型

泛型和类型的区别：

类型：用于约束外部对象的使用场景；存在多态的使用
泛型：用于约束内部对象的使用场景，也称类型参数；不存在多态

原文链接：https://blog.csdn.net/weixin_49555741/article/details/128076709

1. 常见类和对象

1.1 object