Java笔记 常用类(2020.5.30)
（如有问题，欢迎各位大佬批评指正）
常用的类
一:Object类
二:Date类
三:Calender
四:System类
五:String Builder
六:包装类
七:集合框架（Collection）为例
Object类
创建一个Person类
public class Person {
private String name;
private int age;
public Person {
}
//实现equals方法重写
@Override
public boolean equals(Object obj) {
//向下转型obj转为Person类型
Person p = (Person)obj;
//重写之后比较两个对象的属性
boolean b = this.name.equals(p.name) && this.age == p.age;
return b;
}
// @Override
// public boolean equals(Object o) {
// if (this == o) return true;
// if (o == null || getClass() != o.getClass()) return false;
// Person person = (Person) o;
// return age == person.age &&
// Objects.equals(name, person.name);
// }
//
// @Override
// public int hashCode() {
// return Objects.hash(name, age);
// }
public Person (String name, int age) {
this.name = name;
this.age = age;
}
public String getName () {
return name;
}
public void setName (String name) {
this.name = name;
}
public int getAge () {
return age;
}
public void setAge (int age) {
this.age = age;
}
}
应用：
package eaquls;
public class Demo01 {
public static void main(String[] args) {
/*
* Person类默认继承了Object类，所以可以使用equals方法。
* boolean equals(Object obj)指的是其他对象是否与此对象相等
* */
// object类中的equals方法
// public boolean equals(Object obj) {
// return (this == obj);
// }
// this 就是那个对象调用的方法就是内个对象 p1
// obj 就是需要比较的对象 p2
Person p1 = new Person("迪丽热巴", 18);
Person p2 = new Person("迪丽热巴", 18);
// System.out.println("p1:"+ p1);
// System.out.println("p2:"+ p2);
boolean b = p1.equals(p2);
System.out.println(b);
}
}
在jdk7添加了一个工具类，它提供了一些方法来操作对象，它是由一些静态的实用方法组成，这些方法是空指针安全的，用于计算对象的hashcode、返回对象的字符串表示形式，比较两个对象。
Objects
public class Demo01 {
public static void main (String[] args) {
String s1 = "abc";
String s2 = "Abc";
//如果使用object类的equals方法的话，如果s1为空，那么就会出现空指针异常的情况。所以这里我们可以使用Objects的equals方法
boolean b = Objects (s1, s2);
System.out.println (b); //false
}
}
Date类
java.util.Date类 表示特定的瞬间，精确到毫秒
毫秒：千分之一秒，1000ms = 1s
特定的瞬间：就是一个时间点
-
毫秒可以进行时间和日期的计算
-
日期转化为毫秒
- 当前日期
- 时间原点（0毫秒）：1970年1月1日 00:00:00（英国时间）
- 就是计算当前日期到时间原点之间一共经历了多少毫秒
**注意：**中国数据东八区，会把时间增加8小时
-
毫秒转化为日期
- 24h = 24 * 60 * 60 =86400s = 86400000ms
public class Demo {
public static void main (String[] args) {
//获取当前系统时间到时间原点过去了多少毫秒
System.out.println(System.currentTimeMillis())
}
}
- 常用的方法
public class Demo {
public static void main (String[] args) {
date1();
date2();
date3();
}
public static void date3() {
Date date = new Date();
long time = date.getTime();//返回一个long类型的值
System.out.println(time);//获取当前的时间距离原时间的毫秒数
}
public static void date2() {
Date date = new Date(0L);//需要一个long类型的值，就是毫秒数
System.out.println(date);//把毫秒数转化为日期
}
public static void date1() {
Date date = new Date();
System.out.println(date);//获取当前系统的日期
}
}
DateFormate
java.text.DateFormate: 是日期、时间格式化子类的抽象类
作用：格式化（也就是日期–>文本）、解析（文本–>日期）
成员方法：String format （Date date) 按照指定的模式，他Date日期，格式化为符合模式的字符串
Date parse (String source) 把符合模式的字符串，解析为Date日期
DateFormat类是一个抽象类，无法直接创建对象，可以使用它的子类
java.text.SimpleDateFormat(String pattern)
构造方法：SimpleDateFormat(String pattern),用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
参数：String pattern :传递指定的模式
“yyyy-MM-dd HH:mm:ss”
注意事项：模式中的字母不能改，连接模式的符号可以改变
“yyyy年MM月dd日 HH时mm分ss秒”
y 年
M 月
d 日
H 时
m 分
s 秒
package date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class DateFormat {
public static void main(String[] args) throws ParseException {
demo01();
demo02();
}
private static void demo02() throws ParseException {
/*
* 使用DateFormat类中的方法parse，把文本解析为日期
* 1.创建SimpleDateFormat对象，构造方法中传递指定模式
* 2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串，解析为Date日期
* 注意：parse方法声明了一个异常叫做ParseException
* 如果字符串和构造方法的模式不一样，那么程序就会抛出异常
* 调用一个抛出了异常的方法，就必须得处理这个异常，要么throws继续抛出这个异常，要么try catch自己处理
* */
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
Date d = sdf.parse("2020年05月29日 08时56分14秒");
System.out.println(d);
}
private static void demo01() {
/*
* 使用DateFormat类中的format，把日期格式化为文本
* 使用步骤：
* 1.创建SimpleDateFormat对象，构造方法中传递指定的模式
* 2.调用SimpleDateFormat对象中format方法，按照构造方法中指定的模式，把Date日期格式转化为符合模式的字符串
* "yyyy年MM月dd日 HH时mm分ss秒"
* */
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
Date date = new Date();
String d = sdf.format(date);
System.out.println(d);
}
}
Calender类
日历类
Calender类是一个抽象类，里面提供了很多操作日历字段的方法（Year、Month、Day_Of_Month、Hour）
Calendar类无法直接创建对象，里面有一个静态方法叫 getInstance，该方法返回了Calendar类的子对象
static Calendar getInstance()使用默认时区和语言获取一个日历
常用方法
public int get(int field):返回给定日历字段的值。
public void set(int field, int value):将给定的日历字段设置为给定的值
public abstract void add(int field, int amout):根据日历的规则，为给定的日历添加或删去指定的时间量
public Date getTime()：返回给定的日历字段
成员方法的参数
int field:日历类的字段，可以使用Calendar类的静态成员变量获取
public static final int YEAR = 1；年
public static final int MONTH = 2; 月
public static final int DATE = 5; 月中的某一天
public static final int DAY_OF_MONT = 5；月中的某一天
public static final int HOUR = 10；时
public static final int MINUTE = 12 分
public static final int SECOND = 13 秒
public class Demo {
public static void main(String[] args) {
/*
public int get (int field):返回给定日历字段的值
参数：传递指定日历的字段
返回值：日历字段代表的具体的值
public void set (int field):将给定的日历字段设置为定值
参数：int field:传递指定的日历参数
int value: 给定字段设置的值
public abstract void add(int field, int amount):根据日历规则，为给定的日历字段添加或减去指定的时间量
把指定的字段增加或减少
参数：
int field:指定日历字段
int amount:增加或减少的值
正数增加
负数减少
public Date getTime();//返回一个表示此Calendar时间值
就是把日历对象转化为日期对象
Calendar c = Calendar.getInstance();
Date date = c.getTime();
*/
Calendar c = Calendar.getInstance()//多态
int year = c.get(Calendar.YEAR);
System.out.println(year);
int month = c.get(Calendar.MONTH);
System.out.println(month);
int day = c.get(Calendar.DATE);
System.out.println(day);
// c.set(Calendar.YEAR, 5555);
// c.set(Calendar.MONTH,10);
// c.set(Calendar.DATE, 24);
// c.set(2243,1,25); //这是一个set方法的重载，可以直接设置年月日
Calendar c = Calendar.getInstance();
// c.add(Calendar.YEAR, 2);
// int year = c.get(Calendar.YEAR);
// System.out.println(year);
}
private static void demo03() {
Calendar c = Calendar.getInstance();
Date date = c.getTime();
System.out.println(date);
}
}
System类
java.lang.System 类中提供了大量的静态方法，可以互获取与系统相关的信息或系统及操作，在System类的API中常用的方法有：
- public static long currentTimeMillis():返回以毫秒为单位相关的当前时间
- public static void arraycopy(object src, int srcPos, object dest, int length):将数组中指定的数据拷贝到另一个数组中
获取当前时间的毫秒数
public class Demo {
public static void main (String[] args) {
//记录开始开始时间start
long start = System.currentTimeMillis();
//1-100000循环
for (int i = 0; i <= 100000; i++) {
System.out.println(i);
}
//记录结束时间end
long end = System.currentTimeMillis();
System.out.println("运行时间为：" + （end - start) + "毫秒");
}
}
arraycopy(Object src, int srcPos, object dest, int desPos, int length)
将数组中指定的数据拷贝到另一个数组中。
参数：
src: 原数组
srcPos 原数组中的起始索引
dest 目标数组
destPos目标数组中的起始位置
length 要复制的数组元素的数量
练习：
public class Demo {
public static void main(String[] args) {
int [] arr1 = {1, 2, 3, 4, 5};
int [] arr2 = {j, k, l, e, p};
System.arraycopy(arr1, 0, arr2, 0, 3);
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
}
}
String Builder类
- string类：字符串是常量，在创建之后不能改变，字符的地层是一个被final修饰的数组，不能改变，是一个常量。 private final byte 【】 value
- 进行字符串的相加，内存中就会有多个字符串，占用空间多，效率底下
- stringbuilder ：字符串缓冲区，可以提高字符串的操作效率，第层也是一个数组，但是没有被final修饰，可以改变长度。 byte【】value = new byte[16] ，如果超图了StringBuilder的容量，会自动扩容。
构造方法：
StringBuilder（）构造一个不带任何字符串生成器，其初始容量为16字符
StringBuilder（String str）构造一个字符串生成器，并初始化为指定的字符串
public class Demo {
public static void main(String[] args) {
//空参构造方法
StringBuilder bul = new StringBuilder();
//指定字符构造
StringBuilder bul2 = new StringBuilder("abc");
}
}
常用成员方法：
- public StringBuilder append():添加任意类型数据的字符串形式，并返回当前对象自身
- public String toString()：将当前StringBuilder对象转化为String对象
append方法：其实就是往里面添加东西，注意可以添加任意形式
public class Demo01 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append(12).append(true).append('中');
System.out.println(sb);
}
}
toString方法
StringBuilder和String是可以互相转化的
public class Demo {
public static void main(String[] args) {
String str = "Hello";
StringBuilder sb = new StringBuilder(str);
sb.append("World");
System.out.println(sb);//HelloWrold
String sb2 = sb.toString();//转化为String类型
}
}
包装类
概述：Java提供了两个类型系统，基本类型，引用类型，使用基本类型在于效率，然而很多时候，会创建对象使用，因为对象可以做出更多的功能，如果我们想要把基本类型当作对象一样操作，就可以使用基本类型对应的包装类
什么是包装类：
基本数据类型，使用起来非常方便，到那时没有对应的方法来操作这些基本类型的数据可以使用一个类，把基本类型的数据包装起来，在类中定义一些方法，这个类叫做包装类，我们可以把一个包装类当作一个箱子。
| 基本类型 | 对应包类(位于java.lang包) |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
装箱与拆箱
基本类型与对应的包装类对象之间，来回转化的过程称为装箱与拆箱
- 装箱：从基本类型转化为对应的包装类对象
- 拆箱：从包装类对象转化为对应的基本类型
基本数值—>包装对象
Integer i = new Integer(4)//使用构造函数
Integer ii = new Integer.valueOf(4); 使用包装类中的valueOf方法
包装对象—>基本数值
int num = i.inValue();
具体方法：
装箱：把基本类型，包装到包装类中
构造方法：
Integer（int value)构造一个新分配的Integer对象，它表示int值
Integer（String s)构造一个新分配的Integer对象，它表示String 参数所指示的int 值
转递字符串，必须是基本类型的字符串，否则会抛出异常。
静态方法：
static Integer valueOf(int i):返回一个表示指定的 int 值的 Integer 实例
static Integer valueOf(String s) 返回保存指定的String值的 Integer 对象
拆箱：在包装类中取出基本类型的数据
成员方法：int intValue() 以int 类型返回该 Integer 的值
public class Demo {
public static void main(Strint[] args) {
//装箱
//构造方法
Integer in1 = new Integer(1);
System.out.println(in1);
Integer in2 = new Integer("2");
System.out.println(in2);
//静态方法
Integer in3 = Integer.valueOf(3);
System.out.println(in3);
Integer in4 = Integer.valueOf("23");
System.out.println(in4);
//拆箱
int in5 = in1.intValue();
System.out.println(in5);
}
}
自动装箱与自动拆箱
- 自动装箱：直接把int类型的整数赋值包装类
- Integer in = 1；就相当于 Integer in = new Integer(1);
- 自动拆箱：in就是个包装类，无法直接参与计算，可以自动转化为基本数据类型，在参与运算
- in = in + 2;
用一个集合举例子
public class Demo02 {
public static void main (String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);//自动装箱 list.add(new Integer(1));
int a = list.get(0);//自动拆箱 list.get(0).intValue
}
}
基本类型与字符串转化
基本类型–>字符串
- 基本类型的值 + “ ”,就可以直接变成字符串类型，这也是最简单的方法
- 包装类的静态方法：toString（参数）,不是个Object类的toString方法
- static String toString(int i)返回一个表示指定整数的String对象
- String 类中的静态方法 valueOf（参数）
- static String valueOf（int i) 返回 int 类型的字符串表示形式
字符串—>基本类型
- 使用包装类的静态方法 parseXXX (“ 字符串");
- Integer类：static int parseInt(String s)
- Double类：static Double parseDouble（String s)；
public static void main(String[] args) {
//基本类型--->字符串
String a = Integer.toString(13);
System.out.println(a + 14);//不会发生相加 结果是1314
int b = 13;
String c = b + "";
System.out.println(c + 14);//不会发生相加 结果是1314
String d = String.valueOf(13);
System.out.println(d + 14);//不会发生相加 结果是1314
//字符串转基本类型
String lin3 = "13";
int ln4 = Integer.parseInt(lin3);
System.out.println(ln4);
}
包装类
集合框架
JAVASE提供了满足各种需求的API，在使用这些API前，先了解其继承与接口操作架构，才能交接何时采用哪个类，以及类之间如何彼此合作的，从而达到灵活应用。
集合按照其储存结构可分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map,
- Collection：单列集合的根接口，用户储存一些类符合某种规则的元素，它有两个重要的子接口，分别是
java.util.List和java.util.Set。其中List的特点是元素有序，元素可重复，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet
Collection常用功能
是所有单列集合的父接口，因此在Collection中定义了单列集合List和Set通用的一些方法
public boolean add(E e):把给定的对象添加到当前集合中public void clear():清空集合中所有的元素public boolean remove(E e):把给定的对象在当前集合中删除public boolean contains(E e)判断当前集合中是否包含给定的对象public boolean isEmpty():判断当前集合是否为空public int size():返回集合中元素的个数public Object[] toArray()：把集合中的元素，储存到数组中
public static void main(String[] args) {
//创建集合对象，可以使用多态
Collection<String> coll = new ArrayList<String>();
System.out.println(coll);//返回空对象，而不是一个地址值，说明已经重写了toString()方法
//给集合中添加元素 public boolean (E e);添加元素，boolean一般不需要返回值,一般都是返回的是true
boolean boo = coll.add("张三");
coll.add("李四");
coll.add("王五");
coll.add("马六");
coll.add("田七");
System.out.println(boo);
System.out.println(coll);
//Remove方法，删除集合中的元素。删除成功就返回true，删除失败返回false
boolean skt = coll.remove("田七");
System.out.println(skt);
boolean skt1 = coll.remove("老田");
System.out.println(skt1);
//contains：判断集合中时候包含指定的元素，有就返回true，没有就返回false
boolean gen = coll.contains("李四");
System.out.println(gen);
boolean gen1 = coll.contains("马七上");
System.out.println(gen1);
//isEmpty判断当前集合时候为空，也是返回一个布尔值
boolean empty = coll.isEmpty();
System.out.println(empty);
//clear清除集合中的元素
// coll.clear();
// boolean empty1 = coll.isEmpty();
// System.out.println(empty1);
//size返回集合中元素的个数
int a = coll.size();
System.out.println(a);
//toArray把集合转化为数组
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
}