5、Java基础（3）

最新推荐文章于 2023-04-12 16:56:28 发布

尹威的笔记

最新推荐文章于 2023-04-12 16:56:28 发布

阅读量128

点赞数

分类专栏： java学习笔记文章标签： java 字符串

本文链接：https://blog.csdn.net/m0_45016196/article/details/112968594

版权

java学习笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Java基础

1、Object

1.Object是所有类的根类，所有的类都是直接或者间接的去继承Object类。
根类：最上层的类
超类：根类和父类之间的类
2.类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
3.Object里面的方法：
	（1）toString：
返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
	（2）hashCod：
由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。每一个对象都有一个唯一的hash值。
	（3）finalize：
用于垃圾回收，我们不用手动的去调用，由jvm来调用，
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
	（4）equals：
            ==：
            1.基本数据类型：比较的是值
            2.引用数据类型：比较的是地址

2、字符串

字符串是类，是引用的数据类型
String  str = “abc”;
这是定义了一个字符串的常量。常量是不可改变的量，字符串是不能改变的。
	1.字符串常量是共享的
	2.字符串不能变化，如果我们在字符串上做拼接，其实是新产生一个字符串。
空字符串和null的区别：空字符串是有效的引用，有地址的，只不过是内容的长度是0，null这个引用是空引用，不能使用。使用一定会报空指针的错误。引用数据类型的默认值是null。
字符串的常用方法：
	1. boolean equals = s.equals(s1); //判断两个字符串的值是否相等
	2. boolean empty = "".isEmpty();//判断一个字符串是否是空串
	3.int length = s.length();  //获得一个字符串的长度
	4.char[] chars = s.toCharArray();//把字符串转换成字符的数组
	5. String s1 = s.substring(5, 8);//截取指定的开始索引和结束索引之间的字符串，包头不包尾
	6.String[] s1 = s.split("\\-"); //把一个字符串按着某种字符拆分成数组（\\：防止转义字符）

3、可变字符串

StringBuffer创建后值可以变化（增删改），地址不会有变化，不会产生新的字符串。
多个线程同时操作同一个资源的时候，可能发生数据安全性的问题。
StringBuffer是线程同步的（线程安全的）。
注意：凡事有利就有弊，牺牲了性能。
追加：append
可变字符串的追加返回的都是这个可变字符串的本身的引用，所以通过链式方式来追加代码。
插入：insert
删除：delete

4、包装类

把基本数据类型转换成类，我们使用基本数据类型做进制转换很麻烦，对于临界值也不好判断，我们的包装类提供了很多方法供我们使用，这样会方便很多。

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer常用做类型直接的转换（Integer，int，String）
 Integer i = new Integer(10);//int -->Integer
 int i1 = i.intValue();//Integer -->int
Integer i2 = new Integer("55");//String -->Integer
String s2 = i2 + "";//Integer -->String
String s3 = i3 +"";//int -->String
 int i4 = Integer.parseInt(s3);//String -->int
注意：   //包装类不能用 == 比较值
        System.out.println(i == i1);
        //下面是推荐的两种比较相等的方式
        System.out.println(i.intValue() == i1.intValue());
        boolean equals = i.equals(i1);
默认值：基本数据类型int的默认值是0，Integer的默认值是null

5、自动装箱拆箱

装箱：把int类型转换正Integer--------------》new Integer(int i)
拆箱：把Integer转换成int------------》intValue()对象方法
装箱和拆箱是不需要我们主动调用的，是jvm自动给我们完成的。
其他的7种基本数据类型和Integer一样。

6、date

//获得当前的日期时间对象
Date d = new Date();
//日期的格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS E");
String format = sdf.format(d);
//把字符串解析成日期的对象
String s = "1997/12/12 12:34:22";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
try {

    Date date = sdf.parse(s);
    System.out.println(date);

} catch (ParseException e) {
    e.printStackTrace();
}

7、集合

概念：对象的容器，定义对多个对象进行操作的常用方法。可实现数组的功能。
和数组的区别：
	（1）数组长度固定，集合长度不固定。
	（2）数组可以存储基本类型和引用类型，集合只能存储引用类型。
位置：java.util.*;

（1）Collection体系集合

Collection：该体系结构的跟接口，代表一组对象，称为“集合”。
List接口的特点：有序、有下标、元素可重复。
Set接口的特点：无序、无下标、元素不能重复。

Collection接口方法：
    1.add(Object obj)//添加一个对象。
    2.addAll(Collection c)//将一个集合中的所有对象添加到此集合中。
    3.clear()//清空次集合中的所有对象。
    4.contains(Object o)//检查此集合中是否包含o对象。
    5.equals(Object o)//比较此集合是否与指定对象相等。
    6.isEmpty()//判断此集合是否为空。
    7.remove(Object o)//在此集合中移除o对象。
    8.size()//返回此集合中的元素个数。
    9.Object[] toArray()//将此集合转换成数组

遍历元素（重点）
    1.使用增强for
    for(Object o:collection){System.out.println(o);}
	2.使用迭代器（迭代器专门用来遍历集合的一种方式）
    //hasNext();有没有下一个元素
    //next();获取下一个元素
    //remove();删除当前元素
    Iterator it=collection.iterator();
	while(it.hasNext()){
        System.out.println(it.next());
        //不能使用collection删除方法
        it.remove();
    }

（2）List

1.List是有序的集合，就像我们的数组一样。我们可以把list理解为是一个长度可变的数组，而且提供了丰富的api。List的集合底层就是数组。
2.List的迭代器ListIterator
3.通过ListIterator的方式遍历
我们可以使用for循环来动态的遍历List集合
4.List中元素是可以重复的。

方法：
    add(int index,Object o)//在index位置插入对象o。
    addAll(int index,Collection c)//将一个集合中的所有对象添加到此集合中的index位置。
    get(int index)//返回集合中指定位置的元素。
    subList(int fromIndex,int toIndex)//返回fromIndex和toIndex之间的集合元素。

//列表迭代器从后往前
    ListIterator lit=list.listIterator();
	while(lit.hasPrevious()){
        System.out.println(lit.Previous());
    }

（3）ArrayList

数组结构实现，查询快，增删慢；
运行效率快，线程不安全。
ArrayList在添加数据的时候初始的长度是10，后续会以1.5倍来扩充集合的长度。

（4）LinkedList

链表结构实现，查询慢，增删快；
Linked也不是线程安全的。

（5）Vector

数组结构实现，查询快，增删慢；
运行效率慢，线程安全。
Vector底层也是数组。
线程安全的。

（6）HashSet

基于HashCode计算元素存放位置。后者存入。
当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。
存储结构：哈希表（数组+链表+红黑树）
存储过程：
	（1）根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。
	（2）再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表。

（7）TreeSet

基于排列顺序实现元素不重复。
实现了SortedSet接口，对集合元素自动排序。
元素对象的类型必须实现Comparable接口，指定排序规则。
通过CompareTo方法确定是否为重复元素。（CompareTo方法返回值为0，认为是重复元素）
CompareTo：实现定制比较（比较器）

（8）Map集合

特点：
	1.用于存储任意键值对（key-value）
	2.键：无序、无下标、不允许重复（唯一）
	3.值：无序、无下标、允许重复
方法：
	put(K key,V value)//将对象存入到集合中，关联键值。key重复则覆盖原值。
	get(Object key)//根据键获取对应的值。
	entrySet()//返回此映射中包含的映射关系的Set视图。
	keySet()//返回此映射中包含的键的Set视图。

使用entrySet()方法遍历：
    for(Map.Entry<String,String> entry:map.entrySet()){
         System.out.println(entry.getKey()+"---"+entry.getValue());
    }

总结：
	1.HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16.
	2.当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的2倍。目的是减少调整元素的个数。
	3.jdk1.8当每个链表长度大于8，并且数组元素个数大于等于64时，会调整红黑树，目的提高执行效率。
	4.jdk1.8当链表长度小于6时，调整成链表。
	5.jdk1.8以前，链表时头插入，jdk1.8以后时是尾插入。

HashMap:线程不安全，运行效率快；允许用null作为key或是value。
Hashtable:线程安全，运行效率慢；不允许用null作为key或是value。
Properties:Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。
TreeMap:实现了SortedMap接口（是Map的子接口），可以对key自动排序。（元素对象的类型实现Comparable接口）

（9）Collections工具类

集合工具类，定义了除了存取以外的集合常用方法。
//sort排序
Collections.sort(list);
//binarySearch二分查找
Collections.binarySearch(list,13);
//copy复制
Collections.copy(dest,list);
//reverse反转
Collections.reverse(list);
//shuffle打乱
Collections.shuffle(list);
//补充：list转成数组
Integer[] arr=list.toArray(new Integer[0]);
//数组转成集合,集合是一个受限集合，不能添加和删除。（基本类型数组需要修改成包装类型）
List<String> list=Arrays.asList(arr);

8、泛型

本质是参数化类型，把类型作为参数传递。
常见形式有泛型类、泛型接口、泛型方法。
语法：<T,...> T称为类型占位符，表示一种引用类型。
好处：（1）提高代码的重用性。
	（2）防止类型转换异常，提高代码的安全性。

泛型类注意：
	1.泛型只能使用引用类型
	2.不同泛型类型对象之间不能相互赋值。

9、文件

（1）文件构造器

 //文件的构造器是用来创建文件对象的, 我们创建文件对象的时候要保证文件路径正确
File file = new File("D:\\tx.txt");
File file1 = new File("D:\\aaa", "拓薪教育.txt");
//java中的File类的对象可以代表目录，也可以代表文件
File file2 = new File("D:\\aaa");
//根据目录的文件对象创建一个文件
File file3 = new File(file2, "拓薪教育.txt");

（2）创建文件

File file = new File("D:\\aaa\\hello.txt");
//创建一个文件
boolean newFile = file.createNewFile();
//创建一个目录的对象,创建的目录上一层的路径必须正确
File file = new File("D:\\aaa\\bbb");
boolean mkdir = file.mkdir();
//多及目录创建
File file = new File("D:\\aaa\\ccc\\hhh\\ggg");
boolean mkdir = file.mkdirs();

（3）文件删除

File file = new File("D:\\tx.txt");
file.delete();
//删除路径的最后一层, 只有空目录才能被删除
File file1 = new File("D:\\aaa\\bbb");
boolean delete = file1.delete();

（4）文件判断

File file = new File("D:\\tx.txt");
//判断文件是否存在
boolean exists = file.exists();
//判断这个文件对象是否是文件
boolean isFile = file.isFile();
//判断这个文件对象是否是目录
boolean isDir = file.isDirectory();
//判断一个文件对象是否是绝对路径
boolean absolute = file.isAbsolute();
//判断文件是否可读
boolean b = file.canRead();
//判断文件是否可写
boolean w = file.canWrite();
//判断文件是否是隐藏的
boolean h = file.isHidden();

（5）文件获取

File file = new File("D:\\tx.txt");
//获得文件的绝对路径
String absolutePath = file.getAbsolutePath();
//获得的就是当前文件对象的路径
String path = file.getPath();
//获得文件名
String name = file.getName();
//获得tx.txt的大小
long length = file.length();
//获得最后的修改时间
long l = file.lastModified();
//获得电脑磁盘的跟目录
File[] files = File.listRoots();
//获得一个目录下的子文件对象
File file1 = new File("D:\\aaa");
//获得D:\aaa下的子文件对象
File[] files1 = file1.listFiles();
for (File f : files1){
    System.out.println(f);
}
//获得子文件的名字
String[] list = file1.list();
System.out.println(Arrays.toString(list));

10、IO流

（1）概述

流概念：内存与存储设备之间传输数据的通道。
IO概述：IO（Input/Output）:输入和输出，指的是某个设备或环境进行数据的输入或者输出。例如：键盘的输入，再比如显示器就是输出设备，输出图像。
对于java来说输入输出问题，java将它抽象成流对象来解决。
以游戏程序为中心读取文件就是输入，写入文件是输出。

（2）分类

IO流在java中从输入输出角度分类：
	1.输入流：将存储设备中的内容读入到内存中。
	2.输出流：将内存中的内容写入到存储设备中。
IO流在java中从数据的角度来分类：
	1.字符流：以字符为单位，只能读写文本数据。
		文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等
	2.字节流：以字节为单位，可以读写所有数据。
		二进制的数据，这种数据一般用文本打开我们读不懂。比如，图片文件，mp3文件，等等。

（3）字节流

1.输入：
    	//创建文件字节输入流对象
		FileInputStream fis=new FileInputStream("D:\\test.txt");
		//单个字节读取
    	int data=0;
    	while((data=fis.read())!=-1) {
    		System.out.println((char)data);
    	}
		//一次读取多个字节
    	int count=0;
    	byte[] buf=new byte[3];
    	while((count=fis.read(buf))!=-1) {
    		System.out.println(new String(buf,0,count));
    	}
    	fis.close();
2.输出：
    	//创建文件字节输出流对象
		FileOutputStream fos=new FileOutputStream("D:\\test.txt",true);//追加
		//写入文件
        fos.write(97);
        fos.write('b');
        fos.write('c');
		String s="helloworld";
        fos.write(s.getBytes());
    	fos.close();

（4）缓冲字节流

1.输入流：		
		//创建文件字节输入流对象
		FileInputStream fis=new FileInputStream("D:\\test.txt");
        //创建缓冲字节流对象
        BufferedInputStream bis=new BufferedInputStream(fis);
2.输出流：
		//创建文件字节输出流对象
		FileOutputStream fos=new FileOutputStream("D:\\test.txt");
        //创建缓冲字节流对象
        BufferedOutputStream bis=new BufferedOutputStream(fos);    	
		//写入文件
		for(int i=0;i<10;i++){
            bos.write("helloworld".getBytes());//写入缓冲区
            bos.flush();//刷新到硬盘
        }

（5）对象流

使用流传输对象的过程称为序列化、反序列化。（序列化类必须要实现Serializable接口）
    1.序列化(将对象通过流写入到文件)
		//创建文件字节输出流对象
		FileOutputStream fos=new FileOutputStream("D:\\test.txt");
        //创建对象流对象
        ObjectOutputStream oos=new ObjectOutputStream(fos);    
		//序列化（写入操作）
		Student zhangsan=new Student("张三",20);
		oos.writeObject(zhangsan);
		//关闭
		oos.close();
	2.反序列化(将对象通过流读取到内存)
 		//创建文件字节输入流对象
		FileInputStream fos=new FileInputStream("D:\\test.txt");
        //创建对象流对象
        ObjectInputStream ois=new ObjectInputStream(fos);    
		//反序列化（读取文件）
		Student s=(Student)ois.readObject();
		//关闭
		oos.close();   
	3.注意事项：
        （1）序列化类必须要实现Serializable接口。
        （2）序列化类中对象属性要求实现Serializable接口
        （3）序列化版本号ID serialVersionUID，保证序列化的类和反序列化的类是同一个类。
        （4）使用transient（瞬间的）修饰属性，这个属性不能序列化。
        （5）静态属性不能序列化。
        （6）序列化多个对象，可以借助集合实现。

（6）字符流（使用字符流向一个文件输入helloworld）

        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;

        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            writer = new FileWriter(file); //writer = new FileWriter(file, true);追加
            for (int i = 0; i < 100; i++) {
                writer.write("HelloWorld\r\n");
                //每次写入10个helloworld的时候做一次flush
                if(i % 10 == 0){
                    writer.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

（7）缓冲字符流

1.输入流：
    //创建缓冲流
    FileReader fr=new FileReader("D:\\test.txt");
    BufferedReader br=new BufferedReader(fr);
    br.readLine();//行读取
2.输出流：
    //创建缓冲流
    FileWriter fw=new FileWriter("D:\\test.txt");
    BufferedWriter bw=new BufferedWriter(fw);    
    //写入文件
    for(int i=0;i<10;i++){
        bw.write("helloworld".getBytes());//写入缓冲区
        bw.newLine();//写入一个换行符（Windows：\r\n  linux:\n）
        bw.flush();//刷新到硬盘
    }

（8）打印流

//1.创建打印流
    PrintWriter pw=new PrintWriter("D:\\test.txt");
//2.打印
	pw.println(97);

（9）转换流

//创建InputStreamReader对象
    FileInputStream fis=new FileInputStream("D:\\test.txt");
    InputStreamReader isr=new InputStreamReader(fis,"gbk");
//创建OutputStreamWriter对象
    FileOutputStream fos=new FileOutputStream("D:\\test.txt");
    OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");

11、Properties

Properties:属性集合
特点：
	1.存储属性名和属性值。
	2.属性名和属性值都是字符串类型。
	3.没有泛型。
	4.和流有关。

//1.创建集合
Properties properties=new Properties();
//2.添加数据
properties.setProperty("username","zhangsan");
properties.setProperty("age","20");
//3.遍历stringPropertyNames()
Set<String> pronames=properties.stringPropertyNames();
for(String pro:pronames){
    System.out.println(pro+"==="+properties.getProperty(pro));
}
//4.和流有关的方法
//——1.list方法——
PrintWriter pw=new PrintWriter("D:\\test.txt");
properties.list(pw);
pw.close();
//——2.store方法——
FileOutputStream fos=new FileOutputStream("D:\\test.txt");
properties.store(fos,"注释");
fos.close();
//——3.load方法——
Properties properties2=new Properties();
FileInputStream fis=new FileInputStream("D:\\test.txt");
properties.load(fis);
fos.close();