JavaSe基础9

最新推荐文章于 2024-03-19 16:07:14 发布

暗雪之格

最新推荐文章于 2024-03-19 16:07:14 发布

阅读量151

点赞数 1

分类专栏： Javase基础文章标签： java 算法后端

本文链接：https://blog.youkuaiyun.com/snow_original/article/details/131759183

版权

Javase基础专栏收录该内容

12 篇文章

订阅专栏

第九章异常

1、Error: 不可处理，只能采用规避的方式

2、Exception: 可处理

1 NullPointerException：空指针，引用数据类型没有初始化

2 ArrayIndexOutOfBoundsException：数组越界，数组下标超出数组索引范围

3 StringIndexOutOfBoundsException：同ArrayIndexOutOfBoundsException

4 ClasssCastException：类型转换异常，一般是类型不一致所导致的

5 ArithmeticException：除数为0导致

6 NumberFormatException：字符串解析成数字，如果字符串内容不是数字会导致

3、处理Exception方式

try{
   ...
}catch(异常){
    ...
}catch(异常){
    ...
}...
finally{
    //try...catch...执行完成后总会执行里面的内容
}

1 如果try里面代码有Exception异常，并且catch捕获这个异常，异常代码后半部分不会执行，会直接跳转到catch代码块

2 如果try里面代码有Exception异常，但是catch里面没有声明，程序会崩溃

3 如果try里面代码没有Exception异常，catch代码不会执行

4 try…catch…以外的代码正常执行

5 try…catch…执行完成后总会执行里面的内容

6 在方法里如果finally,try,catch都有return那么方法会执行finaly的return

7 写多个catchd的时候要注意父类异常写到之类异常的后面

8 throws: 用在方法上，可以将方法中的异常抛出到使用者，RuntimeException以上的异常会强制使用者处理

4、throw：用来手动抛出异常，还是需要方法使用者处理异常否则程序会崩溃

语法：new 异常类名(String)：参数：提示的信息

1 如果throw的异常是RuntimeException或RuntimeException的子类是不需要throws的，否则需要throws

2 自定义异常：类只要继承了其他异常就是异常类，继承Exception类的异常是必须要处理的

5、Optional：

1 Optional.of(类判空的对象)：没用的

2 Optional.ofNullable(类判空的对象)：初始化Optional

第十章集合

1、相同点：都是容器

不同点：1 数组长度不可变，集合长度可变

2 数组可以存任意类型，集合只能存引用数据类型

3 集合API比数组多

2、Collection：本身是接口，创建集合只能newCollection的子类

1 Collection使用时需要指定泛型，如果不指定默认为Object类型

2 add(泛型); 添加元素

3 size(); 获取集合中元素数量

4 contains(Object); 判断集合内是否有该元素

5 isEmpty(); 判断集合内是否有元素

6 clear(); 清空集合内的所有元素

7 remove(Object); 删除指定元素

3、集合遍历

1 获取迭代器Iterator

2 使用for增强

4、List集合：有序的，可重复

添加方式：add(int,泛型类型)：往指定索引添加数据

获取方式：get(int)：获取指定索引位的值

移除方式：remove(int)。如果调用这个方法需要将数字强转成Integer

是否包含某个元素：contains(Object);

1 ArrayList: 数组结构，线程不安全

2 LinkedList: 链表结构，线程不安全

3 Vector: 线程安全

5、栈结构：先进后出

6、队列结构：先进先出，后进后出

7、数组：查询快，增删慢

8、链表：增删快，查询慢

9、集合的remove(Object)方法，使用时需要对应的引用数据类型重写equals方法

10、泛型：

1 在类里声明泛型格式：类型，T代表任意引用数据类型

2 在类里声明多个泛型格式：类型<T,E,…>，T,E代表任意引用数据类型

3 在方法上声明泛型格式：权限修饰符返回值(可以使用泛型) 方法名(泛型变量名)

4 在接口上声明泛型类型格式：类名，类实现接口时可以将接口·的泛型指定为类上的泛型或者指定成固定的泛型

5 类型通配符：?只能用在指定泛型时

6 设置边界的格式：<? extend 类型名>，只能使用指定类型名或其子类

<? super 类型名>，只能使用指定类型名或其父类

11、Set集合：本身是集合，是Collection子类

底层结构：数组+链表+红黑树

1 不可重复，无序的没有索引

2 实现类

1 HashSet

2 TreeSet：不可重复，从添加元素角度是无序的，从排序角度是有序的

1 红黑树

2 存自定义类型时，自定义的类需要实现comparable接口，默认从小到大排序

3 自定义比较器：在TreeSet的构造方法中实现Comparator接口

3 Set存储自定义类型时需要重写hashcode和equals方法，重写时要保证两个方法重写的属性一致

4 遍历只能用迭代器或者for增强

12、二叉树：每个节点最多有两个分支，最顶端的结点叫做根节点，最末端的结点（没有分支的结点）叫做叶子结点，二叉树最大层数就是它的高度。

13、二叉查找树：

1 小的值存到左侧，大的值存到右侧，相同的值不存

14、平衡二叉树：维持节点的左子树和右子树的高度差小于等于1

1 左旋时，如果新的支点有左右子树，旋转时将左子树断开放到老支点的右侧

2 右旋时，如果新的支点有左右子树，旋转时将右子树断开放到老支点的左侧

注：字符串不可变

15、Map集合

key重复时，值会被覆盖，无序的

1 put(key,value)：存值

2 get(key)：通过key获取value

3 keySet()获取Map集合里面所有key的Set集合

4 entrySet()：获取map集合所有键值对类(Entry)的Set集合，Entry: getkey()：获取key,getvalue()：获取value

两种方式遍历：

1:
Set<String> strings = map.keySet();
for (String str:strings){
    System.out.println("key: "+str+"  values: "+map.get(str));
}
2:
Set<Map.Entry<String,String>> entrySet = map.entrySet();
for (Map.Entry<String,String> entry: entrySet){
    System.out.println(entry.getKey()+","+entry.getValue());
}

5 remove(key)：通过key删除Map集合指定数据

6 clear()：清空集合

7 isEmpyt()：判断Map集合是否为空的

8 size()：获取map中数据数量

9 containsKey(key)：判断Map集合是否包含参数

10 containsValue(value)：判断Map集合是否包含参数

16、Collections:

1 addAll(Collection,…)：向集合里添加元素

2 sort(Collection)：对集合进行排序

3 binarySearch(Collection，object)：查找元素

4 shuffle(Collection)：将集合顺序打乱

5 reverse(Collection)：将集合反转

6 可变参数：

方法参数定义时在类型后面加…

第十一章

1、Stream流

1 获取Stream流

1 Collection子类的stream()

2 stream.of()

2 中间运算

1 filter(Predicate)：筛选，true通过，false不通过

2 limit(int)：截取指定数量

3 skip(int)：跳过指定的数量

4 distinct()：去重

5 Stream.concat(stream1,stream2)：合并流

6 map(Function)：对数据进行自定义修改

3 终结

1 forEach(Consumer)：遍历

2 count()：获取数据数量

4 Stream流收束：

1 collect(Collectors.toList())

2 collect(Collectors.toSet())

3 collect(Collectors.toMap(Function,Function))

/*
	collect(Collectors.toMap(Function,Function))举例
*/
Map<String,String> studentMap = conact.collect(Collectors.toMap(student -> student.name,student -> String.valueOf(student.age)));
        System.out.println(studentMap);

2、File：用来映射文件，文件夹

1 构造：1 new File(路径全名)

2 new File(父路径，文件名)

2 绝对路径：带盘符的路径

相对路径：不带盘符，默认工程所在目录为根目录

3 API:

1 length()：获取文件大小，单位B

2 getName()：获取文件名

3 getPath()：获取File创建时的路径

4 getAbsolutePath()：获取文件绝对路径

5 isFile()：判断是否为文件，true是，false不是

6 isDirectory()：判断是否为文件夹

7 exists()：判断File是否存在于工程

8 lastModified()：获取文件最后修改时间

//示例
Date date = new Date(file.lastModified());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(simpleDateFormat.format(date));

9 file = new File(“a”); createNewFile()创建文件,父路径必须存在

10 file.mkdir()：创建文件夹,父路径必须存在

//原有文件路径
String name = "22-12-29.iml";
File file = new File(name);
//创建文件名
file = new File("文件名");
//创建文件
file = new File(file,"0101.txt");
//创建文件夹
boolean mkdir = file.mkdir();
//创建文件夹的判断
System.out.println(mkdir?"创建成功":"创建失败");
//创建文件的判断
try {
    boolean newFile = file.createNewFile();
    System.out.println(newFile?"创建成功":"创建失败");
}catch (IOException e){
    e.printStackTrace();
}

11 mkdirs()：同时创建多个文件

12 delete()：删除文件或目录

13 listFiles():获取文件夹内所有文件数组

3、IO流：

1 字节流(节点流)：以字节方式进行传输

1 字节读取流（InputStream）：将磁盘数据读取到内存中

FileInputStream

1 read()：读取一字节，当文件结尾时返回-1

2 close()：关闭流

3 read(bytes)：将数据读取到字符数组，当文件结尾时返回-1，否则返回读取的长度。

//1.
String str = "F:\\file\\ProcessFile\\SHUHDIAN\\abc.txt";
		FileInputStream fis = null;
        try {
            fis = new FileInputStream(str);
            int b = 0;
            StringBuilder stringBuilder = new StringBuilder();
            while (((b = fis.read()) != -1)) {
                stringBuilder.append(String.valueOf((char)b));
            }
            System.out.println(stringBuilder);
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
                try {
                    if (fis!=null) {
                        fis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
//2.
String str = "F:\\file\\ProcessFile\\SHUHDIAN\\abc.txt";
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(str);
            byte[] bytes = new byte[8];
            int length;
            StringBuilder stringBuilder = new StringBuilder();

            while ((length = fis.read(bytes))!=-1){
                System.out.println(Arrays.toString(bytes));
                stringBuilder.append(new String(bytes,0,length));
            }
            System.out.println(stringBuilder);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
                try {
                    if (fis!=null) {
                        fis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }

2 字节写入流（OutputStream）：将内存数据写入到磁盘中

FileOutputStream

*** new FileOutputStream(path,append)：path: 文件路径 append: 是否为追加，true为追加，false为不追加，默认为false**

1 write()：将数据写入指定文件中

2 flush()：清空缓冲区，在所有write操作之后调用

3 close()：关闭流

String str = "F:\\file\\ProcessFile\\SHUHDIAN\\abc.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(str,true/*如果不填默认false,覆盖原文件，true为追加文件内容*/);
            fileOutputStream.write(",你好".getBytes(StandardCharsets.UTF_8));
            fileOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

3 字节缓冲流（处理流）：

BufferedInputStream

BufferedOutputStream

2 字符流：只能用来处理中文等多字节表示的文本

1 字符读取流(Reader): FileReader

2 字符写入流(Writer): FileWriter

3 BufferedReader：读取

String str = "F:\\shujujiegou\\a.txt";
        BufferedReader bufferedReader = null;
        FileReader fileReader = null;
        try {
            fileReader = new FileReader(str);
            bufferedReader = new BufferedReader(fileReader);
            String line = null;
            while ((line = bufferedReader.readLine())!=null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

4 BufferWriter: 写入

String str = "F:\\shujujiegou\\a.txt";
        BufferedWriter bw = null;
        FileWriter fw = null;
        try {
            fw = new FileWriter(str,true);
            bw = new BufferedWriter(fw);
            bw.write("以上都是假的");
            bw.newLine();
            bw.write("其实我上一句是假的");
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }