常用类_java_大全(学习笔记ing)

最新推荐文章于 2024-08-12 16:47:32 发布

ro_ta_tion

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量65

点赞数

文章标签： java 学习笔记

本文链接：https://blog.csdn.net/ro_ta_tion/article/details/131168783

版权

一.API

1.API简介

(Application Programming Interface ) 应用程序编程接口，帮助文档，提供java类的介绍，使用方法。

2.文档结构：

(a)Field Summary:类中的属性

(b)Constructor Summary:构造方法介绍

(c)Method Summary:类中的方法

3.查看jdk的源码：

快捷键：

ctrl + shift + t : 查找某个类

Ctrl +o : 查看类中成员

Ctl + t : 查看当前类的层次结构（继承）

4.生成API文档

API文档是根据文档注解生成的。

文档注解以@开始

(a)常用文档注解

- @author 作者
- @date 日期
- @version 版本
- @see 参考内容
- @since 从哪个版本开始支持
- @param 方法参数，格式：@param 参数名称参数描述
- @return 方法返回值，格式：@return 返回值描述
- @throws 方法抛出的异常
- @exception 方法抛出的异常，作用和@throws相同
- @override 重写方法
- @deprecated 已过时，仅为了保证兼容性，不建议使用

(b)设置注解模板

类注解模板：

window - preferences-java-code style - code templates - comments - types - edit

方法注解模板：

window - preferences-java-code style - code templates - comments - Methods- edit

(c)生成文档

cmd : 命令 java doc

eclipse工具 : export - javadoc

如果出现乱码： -encoding utf8;

二 .Object

1.简介

java.lang.object 类所以类的父类/基类，所以类都继承了Object

Object中 11个方法

2.常用方法

getClass	获取对象的运行时类的Class对象
equals	比较两个对象是否相等
hashcode	获取对象的hash值
toString	将对象转为字符串
clone	克隆对象
finalize	对象被回收时调用

2.1getClass

返回对象的运行时类的Class对象。字节码文件

主要用于反射

object中有被native关键词修饰

native 修饰的方法为本地方法，不是由java语言写的，调用的时本地的底层语言 c/C++

User u=new User();
Class c=u.getClass();
Class c1=User.class;
输出class five_thirdToEighth.User

2.2 equals

(a)如果是单纯的比较字符串内容的话:用equals()
(b)如果确实是要比较两个变量的引用的话:用"=="

equals 和 == 区别

1. == 判断基本类型比较的是值，判断引用类型，比较的是地址
2. equals 如果没有重写，默认和 == 没有区别。
3. 如果equals方法被重写了，则按照重写后的规则来比较

public static void eqTest(){
		int n1=1;
		int n2=1;
		System.out.println(n1==n2);    true
		String s1="method";
		String s2="method";
		System.out.println(s1==s2);    String自动转化true
		String s3=new String("a");
		String s4=new String("a");
		System.out.println(s3==s4);    false 传递的是地址
		User a=new User(12,"zhang");
		User b=new User(12,"zhang");
		System.out.println(a==b);    false 传递的是地址
		
		System.out.println(s3.equals(s4));    此时调用的是String中的eq 被重写过
		System.out.println(a.equals(b));
在User类里面利用Generate hashCode() and equals()已经重写过了 或者自己写
	}


class User{
    public boolean equals(User Obj){
		if(this.name==Obj.name){
			return true;
		}
		return false;
	}
}

2.3hashcode

返回的是hashcode值，哈希码

- hashcode是为了支持数据结构中的哈希表 hash table
- 如果不重写，默认返回对象的内存地址
- 如果两个对象的equals比较为true，要求获得hashcode值也相等
- 如果两个对象的equals比较为false,最好hashcode值不等，可能影响哈希表的性能
- 重写equals方法，务必hashcode也重写

2.4 toString

将对象转为字符串形式

- 当直接输出对象时，会自动调用对象的toString,本质输出了toString方法的返回值
- 如果toString没有重写全类名（包名+类名）@十六进制的hashcode值
- 通过重写，输出对象时方便阅读和测试

class User{
    public String toString() {
		return "User [age=" + age + ", name=" + name + ", dog=" + dog + "]";
	}
}

2.5 clone

用于克隆对象

对象被克隆的要求：

(a)实现一个接口 --- Cloneable,表示该类可以被克隆

(b)必须重写clone方法，并且要调用父类的clone方法

浅克隆和深克隆

(a)浅克隆：只克隆对象本身(User)，不可隆它所引用的对象(Dog)，只克隆第一层

所有的其他引用对象依然指向原来的对象

(b)深克隆：把所有对象以及引用对象一起克隆，需要自己实现。

public class User implements Cloneable{
    @Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();//是父类的方法
	}
}

public static void cloneTest() throws CloneNotSupportedException{
User same1=new User(11,"tatanic");
same1.setDog(new Dog("lucky",2));

Object的克隆是浅克隆
User same2=(User) same1.clone();

same2.setName("张三");
获取到原来那一条狗对象
same2.getDog().setDogName("黄蜂");
指向的是同一片内存地址 进行覆盖
System.out.println("same1="+same1);
System.out.println("same2="+same2);
}

same1=User [age=11, name=tatanic, dog=Dog [dogName=黄蜂, dogAge=2]]
same2=User [age=11, name=张三, dog=Dog [dogName=黄蜂, dogAge=2]]

class User{
    public Dog getDog() {
		return dog;
	}
}

class Dog{
    public void setDogName(String dogName) {
		this.dogName = dogName;
	}
}

2.6 finalize

该方法不需要我们调用，由垃圾回收装置调用

GC: garbage collector

垃圾回收机制：

- JVM中存在一个守护线程，用来回收不使用的的对象
- 每一个对象，都会有一个int类型的变量，引用计数器
- 当有一个引用指向当对象时，引用计数+1
- 当有一个引用不在指向当对象时，引用计数-1
- 当引用计数 0 ，gc 该对象成为一个垃圾
- gc 适当的时间对该对象进行回收
- 当对象回收时，自动调用finalize方法
- System.gc();//建议jvm回收垃圾

User f1=new User();//+1
f1=null;//-1
User f2=f1;
System.gc();

三.String

1.字符串

由多个字符组成，java常用的类

创建方法：

(a)直接创建

(b)使用构造方法创建

		String a1="abandon";
		String a2="a";
		String a3=""; 在堆内存中分配了地址
		String a4=new String();	
		
		字符串可和任意类型进行 拼接 +
		System.out.println(a1+22+11);
		System.out.println(a1+true);

2.常用方法

方法名	作用
length	获取字符串的长度
indexOf	获取子字符串第一次出现的位置，如果找不到就返回-1
lastindexOf	获取子字符串最后一次出现的位置
substring	截取字符串，参数为int类型的索引值，返回字符串
charAt	获取索引位置的字符
concat	符串的拼接，很少用
toUpperCase	大写
toLowerCase	小写
contains	判断是否包含指定的子字符串
startWith	判断是否以指定子字符串开头
endWith	判断是否以指定子字符串结尾
trim	去掉首尾空格
replace	替代
equalsIgnoreCase	忽略大小写比较
tochararray	将字符串转为字符数组
getBytes	将字符串转为字节数组
split	将字符串分割为数组
join	将多个元素按照指定的分隔符进行拼接

String a5="world-worthy";
		
		length()获取字符串的长度        
		System.out.println(a5.length());
		
		indexOf()获取子字符串第一次出现的位置，如果找不到就返-1
		System.out.println(a5.indexOf("w"));
		System.out.println(a5.indexOf("w", 3));
		
		lastIndexOf()获取子字符串最后一次出现的位置 
		System.out.println(a5.lastIndexOf("h"));
		
		subString()截取子字符串 左闭右开
		String child=a1.substring(0, 2);
		System.out.println("子串"+child);
		
		charAt()获取索引位置的字符
		char c=a1.charAt(1);
		System.out.println(c);
		
		concat()将字符串连接
		String link=a1.concat("aaa");
		System.out.println(link);
		
		toUpperCase() toLowerCase() 转为大小写
		String u=a1.toUpperCase();
		System.out.println(u);
		System.out.println(u.toLowerCase());
		
		
		tochararray()将字符串转为字符数组
		char[] chars=a1.toCharArray();
		System.out.println(Arrays.toString(chars));
		将字符数组转为字符串
		String s1=new String(chars);
		System.out.println("字符串="+s1);
		
		getBytes 将字符串转为字节数组
		byte[] bytes=a1.getBytes();
		System.out.println(Arrays.toString(bytes));
		将字符数组转为字符串
		String s2=new String(bytes);
		System.out.println("字符串="+s2);
		
		split将字符串分隔为数组
		String[] arrays1=s1.split("");
		System.out.println("分隔后的数组="+Arrays.toString(arrays1));
		String[] arrays2=s1.split("o");
		System.out.println("以o分隔的数组="+Arrays.toString(arrays2));
		
		join()将多个元素按照指定的分隔符进行拼接
		String a6=String.join("-","aa","bb","cc");
		System.out.println(a6);
		String[] a7=new String[]{"dd","ee","ff"};
		System.out.println(String.join("***", a7));

3.字符集

常见的字符集： utf-8,ASCII,GB2312,GBK

public static void main(String[] args) throws UnsupportedEncodingException {
		System.out.println("当前系统的字符集："+System.getProperty("file.encoding"));
		System.out.println("当前jvm的字符集："+Charset.defaultCharset());
		
//		编码：将字符串转为字节数组
		String str="你好，南京";
		byte[] bytes=str.getBytes("gbk");
		System.out.println(Arrays.toString(bytes));
		
//		解码：字节数组->字符串 乱码
		String str1=new String(bytes,"iso8859-1");
		System.out.println(str1);
		
//		重新编码
		byte[] bytes1=str1.getBytes("iso8859-1");
		System.out.println(Arrays.toString(bytes));
		
//		重新解码
		String str2=new String(bytes,"gbk");
		System.out.println(str2);
	}

4.不变性

字符串的值一旦确定，不可修改

不可修改，指的是内存中的值不能再修改，不是变量不能修改

基本类型 值会被覆盖
		int a=1;
		a=2;
		
字符串 重写赋值会重新分配内存空间
		String b="b";
		b="c";

5.常量池

String常量：使用双引号直接创建的字符串，---String常量，字符常量

- 字符常量放在内存的常量池中
- 常量池中的值不会被gc回收，gc不会清理这个区域的内容
- 多次出现的相同字符常量，只会在常量池中创建一个String 对象 -- JVM做了优化

常量池的位置：

jdk1.6 中，常量池在方法区的，是一个永久保存的区域

jdk1.7中，常量池在堆空间中

jdk1.8中，常量池放在与堆空间相对独立的空间

都开辟空间 不需要gc回收
		String n1=new String("aaa");
			   n1=new String("bbb");
			 
字符常量在常量池中 不被回收；有相同的即指向同一片空间	   
	    String n2="ccc";
	    String n3="bbb";
	    String n4="bbb";
	    
引用数据类型 比较地址 
	    System.out.println(n1==n3);false
	    System.out.println(n3==n4);true

6.正则表达式

1.简介

正则表达式有独立的语法，用来检测字符串是否符合特定的规则

正则表达式就是用来定义规则

2.规则

正则表达式由元字符转义字符限定字符构成

(a)元字符：组成正则表达式的字符，让表达式具有一定的逻辑能力，用来判断

(| , {},[ ]，. , \d)

(b)转义字符：\

(c)限定字符:限定匹配的字符个数 (* + ?)

例子	作用
a\|b	只能a或者b
a{5}	只能a或者b
a{5, }	只能a,并且有5位
a{5,7}	5到7位
a*	0到多位
+	1位到多位
?	0到1位
[a-z]{5}	a到z 5位
[a-zA-Z0-9]{6,12}	字母，数字，6-12位
.	任意一个字符
\d	数字
\D	非数字
\w	数字，字母，下划线
\W	非（数字，字母，下划线）
\s	空格
\S	非空格

3.用法

String中支持正则表达式的方法

方法	作用
matches	判断字符串是否匹配某个规则
replaceAll	替换，replace不支持正则表达式
replaceFirst	替换匹配到的第一个
split	分割

a或b任意位
System.out.println("abbaabba".matches("(a|b)*"));

小写字母至少一个
System.out.println("asdfgh".matches("[a-z]{1,}"));
		
数字1到多个
System.out.println("011".matches("\\d+"));
		
小写字母至少4位 数字任意多位
System.out.println("went123456".matches("[a-z]{4,}[0-9]\\d+"));
		
所有2替换为！
System.out.println("hello123hkJH123".replaceAll("\\d{2}","!"));
		
按照数字分割
System.out.println(Arrays.toString("hello12dew5fd7".split("\\d")));
		
只能是数字且有两位 替换为 @
System.out.println("h1jui477hka890hu".replaceFirst("\\d{2}", "@"));

验证手机号码  11  数字  第一位是 1开头
1[0-9]{10}     1\d{10}

5-16位 只能是数字， 字母，下划线，首位要是大写字母
[A-Z]\w{5,16}

四.StringBuffer StringBuilder

1.简介

String 是不可变字符串，不可修改

(a)频繁对String进行修改会在内存中产生多个对象，垃圾数据

(b)String中的方法，但是没有增删改的方法

(c)如果需要频繁对字符串进行修改的操作，建议StringBuffer StringBuilder--- 可变字符串

(d)StringBuffer StringBuilder 基本一致

2.用法

public static void main(String[] args) {
		StringBuffer s=new StringBuffer();
		
用到方法append() 不能和String一样for循环直接追加 str+="hello"
		s.append("abc");
		System.out.println(s);
		s.append("univeral").append(666).append(true);
		System.out.println(s);
		
插入insert() 在指定位置后面插入  从1开始数!!!
		s.insert(1, "unique");
		System.out.println(s);
		
删除delete() 删除索引为[2，6)
		s.delete(2,6);
		System.out.println(s);
		
删除一个deleteCharAt() 删除索引为1的
		s.deleteCharAt(1);
		System.out.println(s);
		
setLength()设置保留字符串长度
		s.setLength(5);
		System.out.println(s);
		
reverse() 逆序
		System.out.println(s.reverse());
		
toString可以转换为String类型 然后用String的方法
		s.toString();
		System.out.println(s);
	}

3.StringBuffer StringBuilder 区别

StringBuffer:

(a)线程安全的（多个人同时访问一个字符串时，不会出问题）
(b)效率低

StringBuilder:

(a)线程不安全的（多个人同时访问一个字符串时，可能会出问题）
(b)效率高

二者与String中的方法有相同的：
length chart indexof lastIndexOf substring replace...

String与StringBuffer测速
String s="";
		Long l1=System.currentTimeMillis();
		for (int i = 0; i <1000; i++) {
			s+="hello";
		}
		Long l2=System.currentTimeMillis();
		System.out.println(l2-l1);
		
		
		Long l3=System.currentTimeMillis();
		StringBuffer q=new StringBuffer();
		for (int i = 0; i < 1000; i++) {
			q.append("hello");
		}
		Long l4=System.currentTimeMillis();
		System.out.println(l4-l3);

eg:删除下标是3的倍数的字符

StringBuffer f=new StringBuffer("123456789");
for (int i = f.length()-1; i >=0; i--) {
			if(i%3==0){
				f.deleteCharAt(i);
		}
}

五.包装类

1.简介

基本数据类型比较简单，不具有面向对象的特点

java给每一个基本类型都提供了一个包装类，具有面向对象的特点。

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

2.基本类型与包装类的转换

(a)拆箱：将包装类转为基本类型

(b)装箱：将基本类型转为包装类

int n=9;
		Integer i=new Integer(9);
		Character c=new Character('c');
		Double d=new Double(1.23);
		
包装类可以调用方法
		i.intValue();
		d.doubleValue();
		
包装类作为参数传递 属于值传递
		Test(i);
		System.out.println(i);

要转成什么样的 就调用哪个的包装类
基本类型转化为包装类————装箱 Integer.valueOf()
		int n1=1;
		Integer n2=new Integer(n1);//手动
		Integer n3=n1;//自动转
		Integer w=Integer.valueOf(n1);
		
将包装类转化为基本数据类型————拆箱 (int类型的数据).intValue()
		Integer n4=new Integer(5);
		int n5=n4.intValue();
		int n6=n4;
		int w2=n4.intValue();
		
基本类和包装类做运算会自动拆箱
		int m1=1;
		Integer m2=new Integer(2);
		System.out.println(m1+m2);
		
		int x=6;
		Integer y=new Integer(6);
		Integer z=new Integer(6);
		System.out.println(x==y);true 值传递
		System.out.println(y==z);false new的地址

3.基本类型和String的转换

(a)基本类型转为字符串

1. valueOf()

String str=String.valueOf(Object obj);

2. 包装类.toString

(b)字符串转为基本类型

包装类.parseXXX();

        int a=12;
		double b=1.2;
		char c='c';
		String s="123456";
		
基本类转为字符串  String.valueOf()
		String a1=String.valueOf(a);
		
包装类.toString 
		String a2=Integer.toString(a);//int->String
		String a3=Integer.toBinaryString(a);
		String b1=Double.toString(b);
		String c1=Character.toString(c);
		
包装类.parseXXX();
		int i1=Integer.parseInt(s);//String->int
		int i2=Integer.parseInt(s, 8);
		System.out.println(i2);
		
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);

六.其他类

1.date

1.1简介

java.util.Date 表示日期

java底层表示日期是long类型---- 当前时间的毫秒数

这个数基于1970/1/1 0:0:0 开始的，这个时间称为计算机的纪元时间（开始的时间）

1.2用法

Date d1=new Date();//默认现在的日期
		System.out.println("d1="+d1);
		System.out.println(d1.getYear());//现在不能用
//获取毫秒值
		System.out.println(d1.getTime());
		Date d2=new Date(278973235870L);
		System.out.println("d2="+d2);
		
指定格式 错误写法
		Date d3=new Date(1999-10-01);
		System.out.println("指定格式:"+d3);
		
指定字符串格式 正确写法 在Java.text包里面找
format是抽象类(父类) DateFormate是直接子类 可以创建对象
		DateFormat d4=new SimpleDateFormat("EEE/YYYY年-MM月-DD日 HH时-MM分-SS秒");
		String s4=d4.format(new Date());
		System.out.println(s4);
		
		
after判断某个时间是否在指定时间之后
before判断某个时间是否在指定时间之后
		Date d5=new Date(100);
		Date d6=new Date(1000);
		System.out.println(d5.after(d6));
		System.out.println(d5.before(d6));

2.Calender

java.util.Calender 表示日历，用来表示日历，日期之间的运算

一个抽象的类，不能直接new关键词创建，使用静态方法getInstance方法获取该类的对象

抽象类：特点一：抽象类可以防止父类被实例化
抽象类不能被实例化
即不能使用new创建一个对象
只能被继承

特点二：
抽象类可保证子类必须重写父类方法
子类继承抽象类后
必须实现或重写抽象类中所有的抽象方法
否则子类仍然为抽象类

特点三：抽象类中可以有抽象方法
也可以没有抽象方法
含有抽象方法的类，必须为抽象类

特点四：抽象类中可以有构造方法
但不是用来创建对象的
而是用来初始化成员属性

Calendar c1=Calendar.getInstance();
		
getTime()   将Calendar转化为Date
		System.out.println("日历原样输出c1="+c1);
		Date d2=c2.getTime();
		System.out.println("Date类有getTime()方法 转化为正常得到日期："+d2);
		System.out.println("——————————————————————————————");
		
setTime()   设置时间 从1970算起 是L类型的
		
		c2.setTime(new Date(3127868274261L));
		System.out.println(c2.getTime());
		System.out.println("——————————————————————————————");
get() 获取日期中指定字段(年 月日)
		System.out.println("年:"+c3.get(Calendar.YEAR));
		System.out.println("月(0-11):"+(c3.get(Calendar.MONTH)+1));
		System.out.println("日:"+c3.get(Calendar.DAY_OF_MONTH));
		System.out.println("一周中的第几天(1-7)(周日是第一天):"+c3.get(Calendar.DAY_OF_WEEK));
		System.out.println("——————————————————————————————");
		
		
        set()
		DAY_OF_WEEK 一周的第几天   返回1-7 1表示星期天
		DAY_OF_MONTH
		DAY_OF_YEAR 一年的第几天
		HOUR
		MINUTE
		SECOND
		MILLISECOND 毫秒

		c4.set(Calendar.YEAR,1990);
		c4.set(Calendar.DAY_OF_MONTH,20);
		c4.set(1999, 01, 11);
		System.out.println(c4.getTime());
		System.out.println("——————————————————————————————");
		
add 添加日期
		c5.add(Calendar.YEAR, 2);
		System.out.println(c5.getTime());
		System.out.println("——————————————————————————————");
		
clear清空
		c6.clear();
		System.out.println(c6.getTime());
		System.out.println("——————————————————————————————");
		
获取毫秒值 get time in millis()
		System.out.println(c6.getTimeInMillis());
		System.out.println("——————————————————————————————");
	}

直接输出Calender类的对象获取长串信息
Data类的getTime()获取毫秒数

直接输出Date类的对象获取具体时间
Calender抽象类的getTime()获取具体时间

3.Math

1.简介

java.lang.Math 用来执行数学运算

Math类中的方法为静态方法

2.方法

常量
        System.out.println(Math.PI);    圆周率
        System.out.println(Math.E);    自然对数
方法round 四舍五入
        double a= 3.567;
        System.out.println((int)a);
        System.out.println(Math.round(a));    返回long类型3.57
        System.out.println(Math.round(a*100)/100.0);
        
floor（a） 返回小于等于参数的最大整数 向下取整
        System.out.println(Math.floor(a));//3
ceil（a）   返回大于等于参数的最小整数 向上取整
        System.out.println(Math.ceil(a));//4
abs 绝对值
        System.out.println(Math.abs(-5));
pow 求次方
        System.out.println(Math.pow(2, 5));
random() 产生 [0,1)的随机数
        System.out.println(Math.random());
[0,100)
        System.out.println((int)(Math.random()*100));
[20,80]
        System.out.println((int)(Math.random()*61)+20);

4.Random

1.简介

java.util.Random 生成随机数

2.方法

创建Random对象
        Random r = new Random();
        
方法 nextInt():随机整数
        System.out.println(r.nextInt());
        System.out.println(r.nextInt(100));    [0,100)
        System.out.println(r.nextInt(61)+20);    [20,80]
        
nextDouble() ：随机[0,1） 
        System.out.println(r.nextDouble());
        
随机布尔
        System.out.println(r.nextBoolean());

这是一边看视频一边学习的笔记-借用了一些老师的笔记内容-如有侵权，通知删除！

新手小白学习之路~~~

ro_ta_tion

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
常用类_java_大全(学习笔记ing)

java.lang.object 类所以类的父类/基类，所以类都继承了ObjectObject中 11个方法正则表达式有独立的语法，用来检测字符串是否符合特定的规则正则表达式就是用来定义规则String 是不可变字符串，不可修改(a)频繁对String进行修改会在内存中产生多个对象，垃圾数据(b)String中的方法，但是没有增删改的方法(c)如果需要频繁对字符串进行修改的操作，建议StringBuffer StringBuilder--- 可变字符串。
复制链接

扫一扫