JavaSE-常用类

JavaSE-常用类

Obeject

Java Object类是所有类的父类，也就是说Java的所有类都继承了Object，子类可以使用Object的所有方法。

Object类位于java.lang包中，编译时会自动导入，我们创建一个类时，如果没有明确一个父类，那么它就会自动继承Object，成为Object的子类。

clone()

obj1.clone();

Object clone() 方法用于创建并返回一个对象的拷贝。返回值为一个对象的拷贝

clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建。

由于Object本身没有实现 Cloneable 接口，所以不重写 clone 方法并且进行调用的话会发生 CloneNotSupportedException 异常。

另外不能在一个子类中访问另一个子类的对象的protected方法，尽管这两个子类继承自同一个父类；此外，子类不能访问父类的对象的protected方法，要通过自己类型的对象才能访问

只能通过自身实例（自身的引用）访问，不能通过父类实例（父类的引用）、其他子类实例（除非是该子类有重写clone()方法）

子类使用继承自父类的clone()方法时，返回的对象仍然是父类类型的对象

public class CloneObject implements Cloneable{

    String name;
    int likes;

    public static void main(String[] args) {

        CloneObject obj1 = new CloneObject();

        obj1.name = "zh1z3ven";
        obj1.likes = 123;

        System.out.println(obj1.name);
        System.out.println(obj1.likes);

        try {

            CloneObject obj2 = (CloneObject) obj1.clone();
            System.out.println(obj2.name);
            System.out.println(obj2.likes);

        }catch (Exception e){
            System.out.println(e);
        }
    }
}
//
zh1z3ven
123
zh1z3ven
123

equals()

object.equals(Object obj);

Object equals() 方法用于比较两个对象是否相等。

equals() 方法比较两个对象，是判断两个对象引用指向的是同一个对象，即比较 2 个对象的内存地址是否相等。

返回值为boolean类型，true or false

public class EqualsObject {

    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();

        System.out.println(obj1.equals(obj2));

        //obj1被赋值给了obj3，此时内存地址，引用都相等，所以为true
        Object obj3 = obj1;
        System.out.println(obj3.equals(obj1));
    }
}

getClass()

获取对象的运行时对象的类。

class<?>是一个泛型，返回值为该运行时对象的类。

import java.util.ArrayList;

public class GetclassObject {
    public static void main(String[] args) {

        Object obj1 = new Object();
        String obj2 = new String();
        ArrayList obj3 = new ArrayList();

        System.out.println(obj1.getClass());
        System.out.println(obj2.getClass());
        System.out.println(obj3.getClass());
    }
}

//结果
class java.lang.Object
class java.lang.String
class java.util.ArrayList

hashCode()

Object hashCode() 方法用于获取对象的 hash 值。

object.hashCode()

返回对象哈希值，是一个整数，表示在哈希表中的位置。

import java.util.ArrayList;

public class HashcodeObject {
    public static void main(String[] args) {
        Object obj1 = new Object();
        String obj2 = new String();
        ArrayList obj3 = new ArrayList();

        System.out.println(obj1.hashCode());
        System.out.println(obj2.hashCode());
        System.out.println(obj3.hashCode());

        String obj4 = obj2;

        System.out.println();
        System.out.println(obj4.equals(obj2));
        System.out.println("obj4 hashcode:" + obj4.hashCode());
        System.out.println("obj2 hashcode:" + obj2.hashCode());
    }
}

//结果
1846274136
0
1

true
obj4 hashcode:0
obj2 hashcode:0

toString()

object.toString()

返回对象的字符串表示形式。

默认返回格式：对象的 class 名称 + @ + hashCode 的十六进制字符串。

数组元素值去toString则返回一个字符串的表示形式 ， 因为 Array 继承了 Object 类，所以可以直接使用toString()方法

public class ToStringObject {
    public static void main(String[] args) {

        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = new Object();

        System.out.println("obj1:" + obj1.toString());
        System.out.println("obj2:" + obj2.toString());
        System.out.println("obj3:" + obj3.toString());


        String array[] = {"agou", "zh1z3ven", "Keefe"};
        System.out.println(array.toString());
        System.out.println(array[1].toString());
    }
}

//结果
obj1:java.lang.Object@6e0be858
obj2:java.lang.Object@61bbe9ba
obj3:java.lang.Object@610455d6
[Ljava.lang.String;@511d50c0
zh1z3ven

String

在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。如果需要修改则需要用StringBuilder或者StringBuffer

在代码中遇到字符串常量时，这里的值是 "zh1z3ven""，编译器会使用该值创建一个 String 对象。

和其它对象一样，可以使用关键字和构造方法来创建 String 对象。

创建字符串的几种方式：

String str = "zh1z3ven";

String str2=new String("zh1z3ven");

//利用字符数组创建字符串
char[] helloArray = { 'z', 'h', '1', 'z', '3', 'v', 'e', 'n'};
String helloString = new String(helloArray);  

str.concat()

将指定的字符串添加到str后面

//字符串拼接
//1、str.concat(string2);
String str4 = "你的名字".concat(str1);
System.out.println(str4);

//2、使用+
String str5 = "agou " + str1;
System.out.println(str5);

str.format()

格式化字符串

//format()格式化字符串
double floatVar =  3.1;
int intVar = 123;
String strVar = "xiaoagou";
System.out.printf("浮点型变量为" + "%f 整型变量为" + "%d 字符串变量为" + "%s ", floatVar, intVar, strVar);
System.out.println();

String fstr;
fstr = String.format("浮点型变量为" + "%f 整型变量为" + "%d 字符串变量为" + "%s ", floatVar, intVar, strVar);
System.out.println(fstr);

str.getBytes()

将字符串编码为 byte 序列，参数为getBytes(String charsetName) ,charseName为字符串编码的名称如UTF-8。此处可以指定编码集将字符串编码为byte序列

//getBytes() 将字符串编码为byte序列存储在一个新的byte数组里
        byte[] str8 = str1.getBytes();
        System.out.println(str8);
        byte[] str10 = str1.getBytes("UTF-8");
        byte[] str9 = str1.getBytes("Unicode");
        System.out.println(str9);
        System.out.println(str10);

        //循环遍历bytes数组
        for (int i = 0; i < str10.length; i++) {
            System.out.println(str10[i]);
            
//result
[B@6ff3c5b5
[B@3764951d
[B@4b1210ee
122
104
49
122
51
118
101
110

str.toCharArray()

//toCharArray()，将字符串转换为新的字符数组
        char array1[] = str1.toCharArray();
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        
z
h
1
z
3
v
e
n

str.subtring()

字符串分割，类似于切片，左闭右开。

//str.subtring()，返回str的子字符串
String str11 = str1.substring(4);
System.out.println(str11);
String str12 = str1.substring(2,5);
System.out.println(str12);

ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

ArrayList 继承了 AbstractList ，并实现了List接口。

初始化：

ArrayList<E> objectName =new ArrayList<>();　

• E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
• objectName: 对象名。

add()

添加一个元素到ArrayList中

ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("xiaoming");
        arrayList.add("xiaoning");
        arrayList.add("xiaoling");
        arrayList.add("xiaoping");
        System.out.println(arrayList);

get()

按下标访问数组元素

//按下标获取ArrayList中的元素   get()
ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("xiaoming");
        arrayList.add("xiaoning");
        arrayList.add("xiaoling");
        arrayList.add("xiaoping");
        
System.out.println(arrayList.get(1));

set()

修改指定数据元素

//修改元素  set()
        arrayList.set(2,"agou");
        System.out.println("修改后为：" + arrayList.get(2));

size()

获取ArrayList长度

//获取ArrayList长度 size()
        int len = arrayList.size();
        System.out.println("arrayList的长度为：" + len);

remove()

删除指定下标元素

//删除元素remove()
        System.out.println("末尾添加一个测试删除元素test");
        arrayList.add("test");
        System.out.println(arrayList);
        arrayList.remove(4);
        System.out.println("删除后的结果为：" + arrayList);

循环遍历

//1、for循环遍历ArrayList
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }

        System.out.println("=================================================");

        //2、for-each循环遍历ArrayList
        for (String i: arrayList
             ) {
            System.out.println(i);
        }

其他引用类型

ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。

如果我们要存储其他类型，而 只能为引用数据类型，这时我们就需要使用到基本类型的包装类。

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Characte

//如果需要讲基本类型放在ArrayList中，则需要指定基本类型的包装类
        ArrayList<Integer> integers = new ArrayList<Integer>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        integers.add(5);
        integers.add(6);
        integers.add(7);
        System.out.println(integers);

Scanner

接收方式有nextLine和next，hashNext方法判断下一个字符是否为空（类似的还有hashNextDouble等等），如遇到空格即停止接收；hashNextLine判断下一行是否为空，即遇到换行停止接收。

public class Demo01 {
    public static void main(String[] args) {

        // 创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        // alt + enter 显示提示快捷键;mac为option + enter

        System.out.println("使用next方式接受：");

        // 判断用户有没有输入字符串

        if (scanner.hasNext()){
            //使用next接受用户输入
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }

        // 用完scanner后关闭，节省资源，凡是io流，用完后需要关闭，节省资源
        scanner.close();
    }
}

Arrays

操作数组的类

Arrays.toString()

public static void main(String[] args) {

        int[] a = {1, 2, 3, 4, 5, 6, 47, 365, 456746, 234, 234234, 785};

        System.out.println(a);      //打印值为数组对象的hashcode

        System.out.println(Arrays.toString(a));     //打印正常数组

        printArray(a);

        System.out.println("===================数组排序===================");

        Arrays.sort(a);     //对数组进行升序排序

        System.out.println(Arrays.toString(a));
    }

    //打印数组
    public static void printArray(int[] a){
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i == a.length - 1){
                System.out.print(a[i]);
            }else {
                System.out.print(a[i] + ", ");
            }

        }
        System.out.println("]");
    }

File

File是文件和目录路径名的抽象表示

文件和目录是可以通过File封装成对象的

对于File而言，其封装的并不是一个真正的文件，仅仅是一个路径名而已。

File构造方法

File(String pathname) 通过将给定的路径名字符串(绝对路径+文件名)转换为抽象路径名来创建新的File实例
File(String parent, String child) 从父路径名字符串(文件所在目录)和子路径名字符串(文件名)创建新的File实例
File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的File实例

public class FileDemo {
    public static void main(String[] args) {
        // File(String pathname) 
        File f1 = new File("/Users/b/Desktop/Typora-Images/test.txt");
        System.out.println(f1);

        // File(String parent, String child) 
        File f2 = new File("/Users/b/Desktop/Typora-Images/","test.txt");
        System.out.println(f2);

        // File(File parent, String child) 
        File f3 = new File("/Users/b/Desktop/Typora-Images/");
        File f4 = new File(f3,"test.txt");
        System.out.println(f4);
        
    }
}

File类创建功能

public boolean createNewFile()	当具有改名成的文件不存在时，创建该文件,返回true，如果存在返回false。若上一级目录不存在的话，抛出io异常。
public boolean mkdir()	创建由此抽象路径名命名的目录
public boolean mkdirs()  创建由此抽象路径名命名的目录，包括任何必须但不存在的父目录

File类的判断和获取功能

public boolean isDirecory() 判断是否为目录
public boolean isFile()  判断是否为文件
public boolean exists()  判断此File是否存在

public String getAbsolutePath()  返回此抽象路径名的绝对路径名字符串
public String getPath()  将此抽象路径名转换为路径名字符串
public String getName()  返回此抽象路径名表示的文件或名录名称

public String[] list()  返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles()  返回此抽象路径名表示的目录中的文件和目录的File对象数组

public class FileFuncDemo {
    public static void main(String[] args) throws IOException {

        File f1 = new File("/Users/b/Desktop/fonts-master 2");
        //isDirecory()
        System.out.println("isDirecory: " + f1.isDirectory());

        //isFile()
        System.out.println("isFile: " + f1.isFile());

        //exists()
        System.out.println("exists: " + f1.exists());

        //getAbsolutePath()
        System.out.println("getAbsolutePath: " + f1.getAbsolutePath());

        //getPath()
        System.out.println("getPath: " + f1.getPath());

        //getName()
        System.out.println("getName: " + f1.getName());

        //list()
        String[] list = f1.list();
        for (String str : list
             ) {
            System.out.println(str);
        }

        //listFiles()
        File[] list2 = f1.listFiles();
        for (File f : list2
             ) {
            System.out.println(f);
        }

    }
}
//
isDirecory: true
isFile: false
exists: true
getAbsolutePath: /Users/b/Desktop/fonts-master 2
getPath: /Users/b/Desktop/fonts-master 2
getName: fonts-master 2
README.rst
Meslo Dotted
FiraMono
DroidSansMonoSlashed
====================
/Users/b/Desktop/fonts-master 2/UbuntuMono
/Users/b/Desktop/fonts-master 2/Tinos
/Users/b/Desktop/fonts-master 2/Monofur

File类删除功能

public boolean delete() 删除由此抽象路径名表示的文件或名录

public static void main(String[] args) throws IOException {

        File f1 = new File("/Users/b/Desktop/java.txt");
        System.out.println(f1.createNewFile());


        if (f1.exists()&f1.isFile()) {
            System.out.println(f1.delete());
        } else {
            System.out.println("此文件不存在");
        }

    }

递归遍历目录

import java.io.File;

public class FileBLDir {
    public static void main(String[] args) {

        File file = new File("/Users/b/Desktop/fonts-master 2/");

        FileBLDir f = new FileBLDir();
        f.fileSearch(file);
    }

    public void fileSearch(File file){
        File[] FDlist = file.listFiles();
        for (File f : FDlist
             ) {
            if (f.isFile()){
                System.out.println(f.getAbsolutePath());
            } else {
                fileSearch(f);
            }
        }

    }

}