JAVA day12:常用类和方法

一、包装类

Java提供两个类型系统 ，基本数据类型和引用数据类型，使用基本类型在于效率，然后特殊情况下，会创建对象使用，因为对象可以有更多的功能。如果我们要以对象形式使用基本类型，需要把基本类型包装成对应对象类型，这个类型叫做包装类。

基本数据类型	对应的包装类(java.lang包中)
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱和拆箱

基本类型与对应的包装类对象之间，来回转换的过程.

装箱：从基本类型转换为对应的包装类对象

拆箱：从包装类转换为对应基本类型。

Integer i=new Integer(10); //使用类构造方法

Integer ii=Integer.valueOf(4); //使用包装类的ValueOf方法 

int num=i.intValue() //上面Integer拆箱到基本数据类型 intVaule

自动装箱与自动拆箱

由于我们经常要做这种转换，从JDK5开始，基本类型与包装类之间装箱和拆箱可以自动完成。

Integer i=4;//自动装箱 // 相当于Integer.valueOf(4);

i=i+5 // i.intValue()+5 //自动拆箱

基本类型与字符串之间转换

基本类型转为字符串

相连接即可：如：34+""

valueOf: String.valueOf(9.1f)->String

toString: Float.toString(3.14f)->String

String转换为基本数据

parse*(String str)

parseByte(String s) ->Byte

parseInt(String s) ->Integer->int

parsDouble(String s)->Double-double

int num=Integer.parseInt("100") ->字符串到包装类拆箱到基本类型
int num=Integer.parseInt("abc") ->抛出 NubmerForamtException 类型

二、String类 -字符串

 java.lang.String类代表字符串，Java程序中所有字符串文字（“abc")都可以看成此类实例

特点：

1. 字符串不变：字符串在创建后不能更改。

String s1="abc";
s1+="d";
System.out.println(s1);// "abcd"
// 在内存中有两个对象”abc"和"abcd"
// s1从最早指向“abc",改变指向，指向“abcd"

2. 因为String对象是不可变的，所以它们可以共享 （常量池）

String s1="abc"
String s2="abc"
//内存中只有一个”abc"对象被创建，同时被s1和s2共享。

 面试题：

public static void main(String[] args) {
String str1="abc";
String str2="abc";
String str3=new String("abc");
String str4=new String("abc");
String str5=str4.intern(); //常量池
System.out.println(str1==str2);//第一行，true
System.out.println(str1==str3);//第二行，false
System.out.println(str1==str5);//第三行，true
System.out.println(str3==str4);//第四行，false
System.out.println(str3==str5);//第五行，false
System.out.println(str1.equals(str2));//第六行，true
System.out.println(str1.equals(str3));//第七行，true
System.out.println(str1.equals(str5));//第八行，true
System.out.println(str3.equals(str4));//第九行，true
System.out.println(str3.equals(str5));//第十行，true
}

 第一行：str1和str2在赋值时，使用的是字符串常量。Java虚拟机有一个常量池机制，它会直接把字符串常量放入 常量池中，从而实现复用。因此str1和str2指向的是常量池中的同一个内存地址，所以返回值是true。

第二行：str3是用new关键字创建的，在Java中，new关键字代表创建一个新对象。因此str3指向的是一个全新的 内存地址。而str1指向的是一个常量池中的旧地址，因此str1和str3肯定是不同的，所以返回值是false。

第三行：str5实际上和str1、以及str2都指向常量池中的同一个对象地址。因此，返回值是true。

第四行：str3和str4使用new关键字分别创建了新的对象，所以返回值是false。

第五行：str3是指向新创建的内存地址，而str5指向常量池中的对象地址，两者是不可能相等的，因此返回值是 false。

对于第六、七、八、九、十行，它们全部使用eqauls()方法进行比较。由于str1、str2、str3、str4、str5这 五个对象的内容都是“abc”，因此它们使用equals方法比较全部是相等的。所以返回值全部是true。

 3. "abc" 等效于char[] data={'a','b','c'};

例如：

String str="abc";

相当于

char data[]={'a','b','c'}

String str=new String(data);//String底层是靠字符数组实现的。

 2.2 使用步骤

查看类

java.lang.String：此类不需要导入

查看构造方法

public String():初始化创建新String对象，里面空字符序列

public String(char[] value):通过char[]来创建String

public String(byte[] bytes):通过byte[]来创建String

String str=new String();//无参构造
char chars[]={'a','b','c'};//通过char[]来创建String
String str2=new String(chars)
byte bytes[]={97,98,99}
String str3=new String(bytes[]);通过byte[]来创建String

 2.3常用方法

2.3.1 判断功能的方法

boolean equals(Object ):将此字符串和指定比较 ，比较的值，比较两个字符串的值是否相等，如果相等则返回true

boolean equalsIgnoreCase(String o):比较时，忽略大小写

public static void main(String[] args) {
String s1="hello";
String s2="hello";
String s3="HELLO";
// equals() 比较的字符串内容是否相同
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//false
System.out.println("============");
System.out.println(s1.equalsIgnoreCase(s1));//true
System.out.println(s1.equalsIgnoreCase(s3));//true
}

2.3.2 获取功能的方法

int length() :获取字符串长度

String concat(String str):将指定的字符串连接到该字符串的末尾

char charAt(int index):返回指定索引处的char值

int indexOf(String str):返回是指定子字符串第一次出现该字符串内的索引；在一个大字符串中查询某个小字符串，如果查询到，则返回该小字符串的位置（索引），如果查询不到则返回-1

String substring(int beginIndex):返回一个子字符串，从beginIndix开始一直到末尾截取字符串

String substring(int beginIndex,int endIndex):返回一个子字符串， beginIndex,~endIndex-》左闭右开

public static void main(String[] args) {
String s="HelloWorld";
System.out.println(s.length());
System.out.println("==================");
String s2=s.concat("**I love Java**");
System.out.println(s2);
System.out.println("=================");
System.out.println(s.charAt(0));
System.out.println(s.charAt(1));
System.out.println("=================");
System.out.println(s.indexOf("l"));//第一次出现索引
System.out.println(s.indexOf("owo"));//-1 找不到
System.out.println("=============");
System.out.println(s.substring(5));
System.out.println(s.substring(3,8));//loWor 3<=s<8 [3,8) 左闭右开 含start
不含end
}

 2.3.3转换功能的方法

char[] toCharrArray()

byte[] getByteds()

String replace(Charequence target,CharSequence replace);字符串替换

trim:删除字符串左右两边的空格

public static void main(String[] args) {
String s="abcde";
char[] chs=s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.print(chs[i]+" ");
}
byte[] bytes=s.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i]+" ");
}
//cd ->CD
String str=
s.replace("cd","CD");
System.out.println(str);
}

2.3.4 分割功能的方法

String[] split(String regex):将此字符串按照给定的regex规则拆分为字符串数组-》（正则表达式）

public static void main(String[] args) {
String s="aa/bb/cc";
String[] strArray=s.split("/");
for (int i = 0; i < strArray.length; i++) {
System.out.print(strArray[i]);
}
}

2.4 String 类的练习

课堂练习

    /**
	  * equals方法作用是：比较两个字符串的值是否相等，如果相等则返回true
	  */
	 @Test
	 public void test1() {
	  String str1 = "Hello";
	  String str2 = "Hello";
	  
	  System.out.println(str1.equals(str2));
	 }
	 
	 /**
	  * substring(first, last)：截取字符串，获得想要的内容
	  * 索引从0开始
	  */
	 @Test
	 public void test2() {
	  String str = "HelloJavaWorld"; //5，9
	  System.out.println(str.substring(5, 9));
	  System.out.println(str.substring(9, 14));
	  System.out.println(str.substring(9));
	 }
	 
	 /**
	  * split:将一个字符串按照指定规则拆分成字符串数组
	  */
	 @Test
	 public void tset3() {
	  String str = "北京#上海#杭州#深圳";
	  String[] arr = str.split("#");
	  for(String s : arr) {
	   System.out.println(s);
	  }
	 }
	 
	 /**
	  * indexOf:在一个大字符串中查询某个小字符串，如果查询到，则返回该小字符串的位置（索引），如果查询不到则返回-1
	  */
	 @Test
	 public void test4() {
	  String str = "28340248724892@qq.com";
	  if(str.indexOf("@") != -1) {
	   System.out.println("合法的邮箱地址");
	  } else {
	   System.out.println("不合法的邮箱地址");
	  }
	 }
	 
	 /**
	  * replace:字符串替换
	  */
	 @Test
	 public void test5() {
	  String str = "28340248724892@qq.com";
	  String str2 = str.replace("qq", "163");
	  System.out.println(str2);
	 }
	 
	 /**
	  * trim:删除字符串左右两边的空格
	  */
	 @Test
	 public void test6() {
	  String str = "   28340248724892@qq.com  ";
	  System.out.println(str.trim());
	 }

拼接字符串

定义一个方法,把数组{1，2，3按照指定的格式拼接成一个字符串，格式【word1#word2#word3】

public static String arrayToString(int[] arrs){
//[word1#word2#word3]
String s=new String("[");
for (int i = 0; i < arrs.length; i++) {
if(i== arrs.length-1){
s=s.concat(arrs[i]+"]");
}else{
s=s.concat(arrs[i]+"#");
}
}
return s;
}
public static void main(String[] args) {
int[] arr={1,2,3};
//调用方法
String s=arrayToString(arr);
System.out.println("s:"+s);
}

统计字符个数

键盘录入一个字符，统计字符串大小写字母及数字字符的个数 录入 字符（大写小写数字） 转换字符数组 是否是大小写或数字 计数

public static void main(String[] args) {
//录入
Scanner sc=new Scanner(System.in);
System.out.println("请输入字符串数据");
String s=sc.nextLine();
//定义
int bigCount=0;
int smallCount=0;
int numberCount=0;
//遍历 得到每个字符
for(int i=0;i<s.length();i++){
char ch=s.charAt(i);
//判断
if(ch>='A'&&ch<='Z'){
bigCount++;
}else if(ch>='a'&&ch<='z'){
smallCount++;
}else if(ch>='0'&&ch<='9'){
numberCount++;
}else{
System.out.println("该字符"+ch+"非法");
}
}
System.out.println(bigCount+"个");
System.out.println(smallCount+"个");
System.out.println(numberCount+"个");
}
}

三.StringBuffer和StringBuilder

StringBuffer是一种可变字符的序列

字符串拼接问题

由于String类对象内容是不可改变的，所以当字符串拼接时，总是会内存中创建一个新对象

字符串的底层是一个被final修饰数组，不能改变，是一个常量

private final byte[] value;

进行字符串相加时，内存中就会有多个字符串，占用空间多，效率低下。

StringBuffer或StringBuilder(版本不同)。

字符串缓存区，可以提高字符串的操作效率（可以看做是一个变长字符串）

底层是一个数组，但是没有用fianl修饰，可以改变长度

byte[] value=new byte[16]

如果字符串拼接，内存中只无需要产生一个对象就可以

StringBuffer或StringBuilder

StringBuffer可称为可变字符序列，带缓冲区的字符串对象，初始化容量16，如果超出这个范围，会在后 面自动增加长度

构造方法

pubic StringBuilder();无参构造

public StringBuilder(String str):加入字符串之后 ，可以由定义变为变长

常用方法

public StringBuiler append(),添加何意类型的字符串形式，并返回StringBuiler

public String toString();StringBuiler转换成String对象

insert方法：将字符（或字符串)插入到该序列的指定位置

delete方法：从该序列中删除指定位置的字符

replace方法：替换该序列中指定位置的字符串

substring方法：字符串截取，返回一个替换好的String值

reverse方法：反转该字符序列

StringBuilder和StringBuffer类的常用方法基本一致，

StringBuffer是线程安全的而StringBuilder是线程不安全的，

在程序多线程开发的环境下，建议使用StringBuffer，否则建议使用StringBuilder ,StringBuilder的效率更高。

课堂练习

    /**
	  * append:向原有的字符串末尾添加新的字符/字符串
	  */
	 @Test
	 public void test1() {
	//  String str = "Hello";
	//  String str = new String("Hello");
	  StringBuffer str = new StringBuffer("Hello");
	  str.append("World");
	  System.out.println(str);
	 }
	 
	 /**
	  * insert:向指定位置插入字符/字符串
	  */
	 @Test
	 public void test2() {
	  StringBuffer str = new StringBuffer("HelloWorld");
	  str.insert(5, "Java");
	  System.out.println(str);
	 }
	 
	 /**
	  * delete:删除指定位置的字符/字符串
	  */
	 @Test
	 public void test3() {
	  StringBuffer str = new StringBuffer("HelloWorld");
	  str.delete(5, 10);
	  System.out.println(str);
	 }
	 
	 /**
	  * replace:替换指定的字符串
	  */
	 @Test
	 public void test4() {
	  StringBuffer str = new StringBuffer("HelloWorld");
	  str.replace(5, 10, "Java");
	  System.out.println(str);
	 }
	 
	 /**
	  * substring:截取字符串
	  */
	 @Test
	 public void test5() {
	  StringBuffer str = new StringBuffer("HelloWorld");
	//  String s = str.substring(5, 10);
	  String s = str.substring(5);
	  System.out.println(s);
	 }
	 
	 /**
	  * reverse:反转截取字
	  */
	 @Test
	 public void test6() {
	  StringBuffer str = new StringBuffer("HelloWorld");
	  str.reverse();
	  System.out.println(str);
	 }

四、 Math类

java.lang.Math包含执行基本数学运算的方法，对数，平方根和三角函数

4.1 基本运算方法

static double abs(double a):double的绝对值

Math.abs(-5); // 5
Math.abs(5); // 5

static double ceil(double a):返回大于等于参数的最小的整数

Math.ceil(3.3) //4.0
Math.ceil(-3.3)//-3.0
Math.ceil(5.1) // 6.0

 static double floor(double a)返回小于等于参数的最大的整数

Math.floor(3.3) // 3.0
Math.floor(-3.3)//-4.0
Math.floor(5.1) //5.0

 static long round(double a):返回最接近参数long(四舍五入)

Math.round(5.5);//6.0
Math.round(5.4);//5.0

PI静态常量：表示圆周率

Math.sqrt()：求平方根

floor方法：小数取整，向下取整

ceil方法：小数取整，向上取整

round方法：小数取整，四舍五入

random方法：获取一个0-1(不包含1)的随机小数

4.2 练习

计算-10.8到5.9之间，绝对值大于6或小于2.1 整数有多少

public static void main(String[] args) {
//最小值
double min=-10.8;
//最大值
double max=5.9;
//定义计数器
int count=0;
for(double i=Math.ceil(min);i<=max;i++){
if (Math.abs(i) > 6 || Math.abs(i)<2.1) {
count++;
}
}
System.out.println("个数为"+count+"个");
}

课堂练习：

/**
	 * PI:圆周率
	 */
	@Test
	public void test1() {
		System.out.println(Math.PI);
	}
	
	/**
	 * floor:小数取整，向下取整4.9-->4
	 */
	@Test
	public void test2() {
		System.out.println(Math.floor(4.9));
	}
	
	/**
	 * ceil:小数取整，向上取整4.1-->5
	 */
	@Test
	public void test3() {
		System.out.println(Math.ceil(4.1));
	}
	
	/**
	 * round:小数取整，四舍五入4.1-->4；4.5-->5
	 */
	@Test
	public void test4() {
		System.out.println(Math.round(4.1));
		System.out.println(Math.round(4.5));
	}
	
	/**
	 * random:生成一个0-1之间的随机小数（包含0，不包含1）
	 */
	@Test
	public void test5() {
		for(int i=0; i<10; i++) {
			System.out.println(Math.random());
		}
	}

五、Random类

用于生成伪随机数

步骤

import java.util.Random

public Random():创建一个新随机数的生成器

public int nextInt(int n):返回一个随机数，范围0（包括）和指定值n(不包据)之间int值

nextBoolean方法：用于生成一个随机boolean值

nextDouble方法：用于生成一个0-1(不包括1)之间的随机小数

nextlnt(int end)方法：用于生成一个0至指定值的随机整数，不包括整个指定的值

 生成3个10以内随机整数

public class RandTest {
public static void main(String[] args) {
Random r=new Random();
for(int i=0;i<3;i++){
int number=r.nextInt(10);
System.out.println(number);
}
}
}

创建一个Random对象，每次调用nextInt()方法，都会生成一个随机数

 获取1~n之间的随机数，包含n

public class RandomtTest02 {
public static void main(String[] args) {
int n=50;
Random r=new Random();
int number=r.nextInt(n)+1;
System.out.println("number:"+number);
}
}

课堂练习：

/**
	 * nextBoolean:随机生成一个布尔类型的值
	 */
	@Test
	public void test1() {
		Random r = new Random();
		for(int i=0; i<10; i++) {
			System.out.println(r.nextBoolean());
		}
	}
	
	/**
	 * nextDouble:随机生成一个0-1之间的小数（包含0不包含1）
	 */
	@Test
	public void test2() {
		Random r = new Random();
		for(int i=0; i<10; i++) {
			System.out.println(r.nextDouble());
		}
	}
	
	/**
	 * nextInt:随机生成一个0-n之间的正数（包含0不包含n）
	 */
	@Test
	public void test3() {
		Random r = new Random();
		for(int i=0; i<10; i++) {
			System.out.println(r.nextInt(10));
		}
	}

六、System类

java.lang.System类，提供大量静态方法，获取与系统相关的信息或系统级操作，

static long currentTimeMillits(): 返回以毫秒为级别的当前时间

static void arrayCopy(Object src,int srcPos,Object dest,int desPos,int length):将数组中指定数据拷贝到 另一个数组中。

currentTimeMillis方法

获取当前系统时间与1970年01月01日00:00:00之间的毫秒差值

public static void main(String[] args) {
System.out.println(System.currentTimeMillis());
long before=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
System.out.println("helloWorld");
}
long after=System.currentTimeMillis();
System.out.println("共用了"+(after-before)+"ms");
}

arraycopy方法

阅读源码

public static void main(String[] args) {
int[] src={1,2,3,4,5};
int[] dest={6,7,8,9,10};
System.arraycopy(src,0,dest,0,3);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+" ");
//src数组 [1,2,3,4,5]
//dest 数组[6,7,8,9,10]
//dest 数组[1,2,3,9,10]
}
}

exit方法：终止当前正在运行的Java虚拟机

print方法:向控制台输出信息

七、SimpleDateFormat

日期、时间格式化类

format方法:格式化日期(yy-MM-dd hh:mm:ss)

parse方法:将字符串转换为日期

/**
	 * format:格式化日期（yyyy-MM-dd hh:mm:ss）year,month,day hour:minute:second
	 */
	@Test
	public void test1() {
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
		System.out.println(sdf.format(d));
	}
	
	/**
	 * parse:把一个合格的字符串转换成一个日期对象
	 * @throws ParseException 
	 */
	@Test
	public void test2() throws ParseException {
		String str = "2021-08-19 04:09:01";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		Date d = sdf.parse(str);
		System.out.println(d);
	}

八、Date

获取日期

getTime方法:获取当前时间的毫秒数，从1970年1月1日开始

toLocaleString方法:获取当地时间，返回值是一个字符串

/**
	 * getTime:获取当前时间的毫秒数，从1970年1月1日开始(1秒=1000毫秒，1s=1000ms)
	 */
	@Test
	public void test1() {
		Date d = new Date();
		System.out.println(d.getTime());
	}
	
	/**
	 * toLocaleString:获取当地时间，返回值是一个字符串
	 */
	@Test
	public void test2() {
		Date d = new Date();
		System.out.println(d.toLocaleString());
	}

九、Calendar

日期、时间处理的抽象类

常用的日期常量
YEAR、MONTH、DATE、DAY_OF_WEEK、DAY_OF_MONTH、WEEK_OF_MONTH、WEEK_OF_YEAR

get方法：通过Calendar提供的日期常量获取指定的日期

/**
	 * Calendar-->get:YEAR、MONTH、DATE、DAY_OF_WEEK、DAY_OF_MONTH、WEEK_OF_MONTH、WEEK_OF_YEAR
	 */
	@Test
	public void test() {
		Calendar c = Calendar.getInstance(); //实例化Calendar对象
//		System.out.println(c.get(Calendar.YEAR));  //查询现在时刻在哪一年
//		System.out.println(c.get(Calendar.MONTH)+1);  //查询现在时刻在哪一月（从0开始查）
//		System.out.println(c.get(Calendar.DATE));  //查询现在时刻在当前月份的哪一天
		System.out.println(c.get(Calendar.DAY_OF_WEEK)); //查询星期几，从周日开始
	}

十、Object

getClass方法：返回该对象的运行时类

hashCode方法：返回该对象的哈希码，返回值是整数型

toString方法：返回该对象的信息，返回值是字符串

@Test
	public void test() {
		StringBuffer sb = new StringBuffer("Hello");
		StringBuffer sb1 = new StringBuffer("书法房东撒");
		System.out.println(sb.getClass()); //获取指定对象运行时的类，包名+类名
		System.out.println(sb.hashCode()); //获得指定对象的hashcode,哈希码，整数型
		System.out.println(sb.toString); //返回该对象的信息，返回字符串
	}