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

接收方式有nextLinenexthashNext方法判断下一个字符是否为空(类似的还有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);
}
} } }

JavaSE-常用类的更多相关文章

  1. JavaSE常用类之File类

    File类 只用于表示文件或目录的信息,不能对文件内容进行访问. java.io.File类∶代表文件和目录.在开发中,读取文件.生成文件.删除文件.修改文件的属性时经常会用到本类. File类不能访 ...

  2. JavaSE 常用类与其方法

    1.基本数据类型比较用:== 2.引用数据类型比较用:equals方法 如果引用数据类型使用==比较的话,比较的是地址值 toString类 对象调用toString()需要重写本方法: 在封装类中, ...

  3. JavaSE常用类之Object类

    1. hashCode方法 代码: package NeiBuLei; public class hashCode { public static void main(String[] args) { ...

  4. JavaSE学习笔记(8)---常用类

    JavaSE学习笔记(8)---常用类 1.Object类 java.lang.Object类是Java语言中的根类,即所有类的父类.它中描述的所有方法子类都可以使用.在对象实例化的时候,最终找的父类 ...

  5. Foundation框架下的常用类:NSNumber、NSDate、NSCalendar、NSDateFormatter、NSNull、NSKeyedArchiver

    ========================== Foundation框架下的常用类 ========================== 一.[NSNumber] [注]像int.float.c ...

  6. JS面向对象(1) -- 简介,入门,系统常用类,自定义类,constructor,typeof,instanceof,对象在内存中的表现形式

    相关链接: JS面向对象(1) -- 简介,入门,系统常用类,自定义类,constructor,typeof,instanceof,对象在内存中的表现形式 JS面向对象(2) -- this的使用,对 ...

  7. Java集合常用类特点整理

    集合的结构如下图所示: 集合的两个顶级接口分别为:Collection和Map Collection下有两个比较常用的接口分别是List(列表)和Set(集),其中List可以存储重复元素,元素是有序 ...

  8. Java集合框架(常用类) JCF

    Java集合框架(常用类) JCF 为了实现某一目的或功能而预先设计好一系列封装好的具有继承关系或实现关系类的接口: 集合的由来: 特点:元素类型可以不同,集合长度可变,空间不固定: 管理集合类和接口 ...

  9. java-API中的常用类,新特性之-泛型,高级For循环,可变参数

    API中的常用类 System类System类包含一些有用的类字段和方法.它不能被实例化.属性和方法都是静态的. out,标准输出,默认打印在控制台上.通过和PrintStream打印流中的方法组合构 ...

  10. Java基础复习笔记系列 五 常用类

    Java基础复习笔记系列之 常用类 1.String类介绍. 首先看类所属的包:java.lang.String类. 再看它的构造方法: 2. String s1 = “hello”: String ...

随机推荐

  1. java -jar 运行springboot项目时内存设置

    java -Xms64m #JVM启动时的初始堆大小 -Xmx128m #最大堆大小 -Xmn64m #年轻代的大小,其余的空间是老年代 -XX:MaxMetaspaceSize=128m # -XX ...

  2. 第12次抽考(GUI)

    1. package week4; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JTextFiel ...

  3. DNS配置【正向解析】

    DNS配置.正向解析                一.BIND域名服务基础                  1)DNS的定义                  2)域名结构             ...

  4. C:汉字存储

    问题 C语言中汉字如何存储?梳理思路! 答案 在计算机中,一个英文字符占1个字节,汉字占两个字节,如果用char字符数组存储字符时,需要在最后面自动加上一个字节的结束符"\0" 汉 ...

  5. C语言:\t\b\n应用

    #include <stdio.h> int main() { printf("123\n"); printf("%c\n",'\177'); pr ...

  6. C语言:Unicode字符集

    Unicode 也称为统一码.万国码:看名字就知道,Unicode 希望统一所有国家的字符编码.Unicode 于 1994 年正式公布第一个版本,现在的规模可以容纳 100 多万个符号,是一个很大的 ...

  7. 双线性插值算法的FPGA实现

    本设计预实现720P到1080P的图像放大,输入是YUV444数据,分量像素位宽为10bit,采用的算法为双线性插值法,开发平台是xiinx K7开发板. 双线性插值法即双次线性插值,首先在横向线性插 ...

  8. Ubuntu18.04 安装opensips,实现局域网内sip语音视频通话

    Ubuntu18.04直接安装opensips 本人实践亲测有效,用docker安装opensips尝试多次均无法连接mysql数据库,故舍弃,直接在主机上安装opensips 部分内容参考自:htt ...

  9. Day7 break continue goto 以及打印三角形练习.

    break break在任何循环语句中的主体部分,均可以用break控制循环流程.break用于强行退出循环,不执行循环中剩余的语句. (break语句也在switch中使用) package com ...

  10. IO编程之对象序列化

    对象序列化的目标是将对象保存在磁盘中或者允许在网络中直接传输对象.对象序列化机制循序把内存中的java对象转换成平台无关的二进制流,从而允许把这种二进制流持久的保存在磁盘上,通过网络将这种二进制流传输 ...