java中的常见类

最新推荐文章于 2022-06-13 15:19:30 发布

一生而已

最新推荐文章于 2022-06-13 15:19:30 发布

阅读量202

点赞数 2

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_38114301/article/details/97259263

版权

java基础专栏收录该内容

15 篇文章 6 订阅

订阅专栏

java中常用类

String类

String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。String类对象创建后不能修改。这时我们会问，为什么我们String变量赋值不就是改变了吗？其实不是的，赋值后将会生成新的对像来存放新的内容，原先的对象依旧在内存中，但是s不在指向它，那么这个对象就会成为垃圾内存，在某一个特定的时刻有Java虚拟机回收。

String：

字符串：一组字符序列 (不可变的串)
创建String对象：
new String();
new String(“abc”);
new String(buf,2,2);//通过字节数组创建

StringBuffer：

StringBuilder(jdk1.5之后才有的)

String类中的部分构造器代码说明

public class Text01 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		// String 构造器
				String str1 = new String();//是一个""对象
				System.out.println(str1);
				// 通过双引号直接创建String对象
				String str2 = "love";//通过字符串常量直接创建String对象 
				//通过字符串常量给str3赋值
				String str3 = "";
				//比较str1和str3
				System.out.println(str1==str3);
				//按照字节数组创建字符串对象
				byte[] buf = new byte[] {65,66,67,68,69};
				String str4 = new String(buf);
				System.out.println("通过字节数组创建字符串："+str4);
				str4 = new String(buf,2,2);
				System.out.println("通过字节数组创建字符串："+str4);
				
				str4 = new String(buf,2,2,"UTF-8");
				System.out.println("通过字节数组创建字符串："+str4);
				//按照字符数创建字符串对象
				char[] ch = new char[] {'袁','雄','章','啦','来'};
				str4 = new String(ch);
				System.out.println("通过字符数组创建字符串:"+str4);
				str4 = new String(ch,2,2);
				System.out.println("通过字符数组创建字符串:"+str4);
				//按照代码点创建字符对象
				int[] in = new int[] {97,98,100,101};
				str4 = new String(in,2,2);
				System.out.println("按照代码点创建字符对象"+str4);
	}
}

String类中部分方法代码说明

package com.mage.string;

import java.util.Arrays;

/*
 *  String 的常见方法： 
 */
public class Test02 {
	public static void main(String[] args) {
		
		// 创建一个String对象
		String str = "ilovejavaandlaoxue";
		
		//charAt(int index);
		char ch = str.charAt(3);
		System.out.println("返回当前索引位置上的指定字符："+ch);
		
		//codePointAt(index)
		int num = str.codePointAt(0);
		System.out.println("返回指定索引位置上元素的代码点："+num);
		
		//compareTo(String)
		String cStr = "ilovejavaandlaoxu";
		num = str.compareTo(cStr);
		System.out.println("比较两个字符串的大小："+num);
		
		//compareToIgronCase(String)
		cStr = "ILOVEJAVAANDLAOXUE";
		num = str.compareToIgnoreCase(cStr);
		System.out.println("比较两个字符串的大小（忽略大小写）："+num);
		
		//concat(String)
		cStr = "andgirl";
		str = str.concat(cStr);		
		System.out.println("拼接之后的结果是："+str);
		
		
		//copyValueOf(char[])
		char[] chs = new char[] {'i','l','o','v','e'};
		str = String.copyValueOf(chs);
		System.out.println("创建新的字符串："+str);
		
		str = String.copyValueOf(chs,1,4);
		System.out.println("创建新的字符串："+str);
		
		str = "憨憨.avi";
		boolean flag = str.endsWith(".avi");
		System.out.println("str是否是.avi格式："+flag);
		
		//getBytes
		byte[] buf = str.getBytes();
		System.out.println("获取字符串的字节数组："+Arrays.toString(buf));
		
		//getChars();
		chs = new char[10];
		//  从str的2索引处开始  到str的第5个索引结束(不包含)  复制到chs字符数组中 从第1个位置开始
		str.getChars(2,6, chs, 1);
		System.out.println("获取字符串的字符数组："+Arrays.toString(chs));
		
		//indexOf  返回负数代表未找到
		str = "hehe.avi.png";
		int index = str.indexOf(".");
		System.out.println(".在string中第一次出现的位置是："+index);
		
		index = str.indexOf(100);
		System.out.println("e在string中第一次出现的位置是："+index);
		
		index = str.indexOf(".",5);
		System.out.println(".在string中第5个索引位置开始计算，第一次出现的位置是："+index);
		
		index = str.lastIndexOf(".");
		System.out.println(".在string中最后一次出现的位置是："+index);
		
		//isEmpty()
		System.out.println("查看数组是否为null:"+str.isEmpty());
		
		//repleace
		str = "hehe.avi.png";
		str = str.replace(".", "+");
		System.out.println("替换之后的结果："+str);
		
		//splite:
		str = "login?unme=zs&pwd=zs";
		
		String[] strs = str.split("\\?");
		for(String string:strs) {
			System.out.println(string);
		}
		System.out.println("======");
		String parms = strs[1];
		strs = parms.split("&");
		for(String string:strs) {
			String[] ss = string.split("=");
			System.out.println(ss[1]);
		}
		//subString
		str = "login?unme=zs&pwd=zs";
		str = str.substring(4);// 从4索引开始截取到结束
		System.out.println("截取字符串："+str);
		
		str = str.substring(2, 7);//从2索引开始截取 到索引为7结束不包含7
		System.out.println("截取字符串："+str);
		
		//大小写转换
		str = "login?unme=zs&pwd=zs";
		str = str.toUpperCase();
		System.out.println("转为大写："+str);
		str = str.toLowerCase();
		System.out.println("转为小写："+str);
		//通过静态方法创建String对象
		String str1 = String.valueOf(123);
		System.out.println(str1);
		//对象转字符串 其实就是调用当前对象的toString方法
		User u = new User(10);
		String str2 = String.valueOf(u);
		System.out.println(str2);	
	}
}

class User{
	private int age;
	public User() {
		// TODO Auto-generated constructor stub
	}
	public User(int age) {
		super();
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [age=" + age + "]";
	}
	
	
}

String中常见的面试题

public class StringPool {
    public static void main(String[] args) {
        String s1 = "Cat";
        String s2 = "Cat";
        String s3 = new String("Cat");
        
        System.out.println("s1 == s2 :"+(s1==s2));//true
        System.out.println("s1 == s3 :"+(s1==s3));//flase
    }
}

内存分析

在这里插入图片描述

StringBuffer和StringBuilder类

StringBuilder和StringBuffer 都继承了AbstractStringBuilder
StringBuffer效率低于StringBuilder
StringBuffer安全性要高于StringBuilder
一般情况下使用StringBuilder
jdk9之后 String中存储数据通过byte数组存储 + 变量
jdk中对于String存储时的内容消耗极大降低

谈一下String,StringBuffer，StringBuilder的区别？

String: 不可变的字符序列
StringBuffer:线程安全的可变字符序列，其效率小于StringBuilder
StringBuilder:线程不安全的可变字符序列，但是效率高于StringBuffer
StirngBuffer和StirngBuilder都继承自AbstractStringBuilder, AbstractStringBuilder和String都继承自Object.

包装类

包装类：

8大基本数据类型 -> 8个包装类
byte->Byte
short->Short
char ->Character
int ->Integer
long ->Long
float->Float
double->Double
boolean->Boolean

jdk12 Integer中的所有构造器都过时通过valueOf方法获取int对应的Integer对象。

实例代码

public class Test01 {
	public static void main(String[] args) {
		
		//静态成员变量
		System.out.println("BYTES:"+Integer.BYTES);
		System.out.println("MAXVALUE:"+Integer.MAX_VALUE);
		System.out.println("MINVALUE:"+Integer.MIN_VALUE);
		System.out.println("SIZE:"+Integer.SIZE);
		System.out.println("CLASS:"+Integer.TYPE);
		
		//构造器
		Integer in1 = new Integer(12);
		
		System.out.println(in1);
		
		Integer in2 = new Integer("123");// 可能出现数字格式化异常
		
		System.out.println(in2);

		System.out.println(Integer.max(12, 20));
		
		//parseInt(String)
		System.out.println("字符串转为int："+Integer.parseInt("1234"));
		System.out.println("字符串转为int："+Integer.parseInt("1100",2));// 将一个对应进制的数值变为对应十进制的字符串
		
		
		//System.out.println(""+Integer.reverse(Integer.MAX_VALUE));//将当前数值在计算机中存储的补码进行翻转得到的十进制的数
		
		System.out.println("2进制:"+Integer.toBinaryString(Integer.MAX_VALUE));
		
		System.out.println("8进制:"+Integer.toOctalString(12));
		
		//获取Integer对象
		Integer in3 = Integer.valueOf(12);
		System.out.println(in3);
		
		Integer in4 = Integer.valueOf("12");
		System.out.println(in4);
		
	}
}

jdk1.5之后支持自动拆装箱

装箱：Integer.valueOf()
拆箱：对象.intValue()
自动装箱时，首先会判定当前的值是否在缓冲区中[-128,127],如果再改区间中，直接从缓冲区中获取对应的Integer对象
反之会重新创建一个新的Integer对象

代码示例

public class Test02 {
	public static void main(String[] args) {
		
		Integer in1 = 123;//jdk1.5之后支持自动装箱  Integer.valueOf(123);
		int num = in1;//jdk1.5之后支持自动拆箱 in1.intValue();
		
		
		Integer in2 = 88;
		Integer in3 = 88;
		System.out.println(in2==in3);
		
		in2 = 127;
		in3 = 127;
		System.out.println(in2==in3);
		
	}
}

面试题型

/*
以下代码会出现什么问题？答案：不会出现问题
*/
public class Test {
    public static void main(String[] args) {
       int num = 10;
       test(10);
       test(Integer.valueOf(10));
}
public static void test(Long in1){
    System.out.println(in1);
}
public static void test(long in1){
    System.out.println(in1);
}
}

创建Boolean对象

字面值创建Boolean对象时只能指定true和false 并且创建的对象也是对应的true和false
字符串创建Boolean对象是只要字符是true/false 无所谓大小写得到对应的Boolean对象就是与之对应的true和false
其它所有字符串赋值都是false

代码示例

public class Test03 {
	public static void main(String[] args) {
		
		// 创建Boolean对象
		Boolean f1 = new Boolean(true);
		System.out.println(f1);
		
		f1 = new Boolean(false);
		System.out.println(f1);
		
		f1 = new Boolean("1");
		System.out.println(f1);
		
		f1 = new Boolean("0");
		System.out.println(f1);
		
		f1 = new Boolean("TRue");
		System.out.println(f1);
		
		f1 = new Boolean("False");
		System.out.println(f1);
		
		f1 = new Boolean("123");
		System.out.println(f1);
		
	}
}

再谈方法重写

对于一个方法而言：区分方法通过方法名找方法通过参数列表来确定方法。

方法重写：

发生继承关系、实现关系父类不满足子类的需求子类重写父类中的方法。

什么情况下会发生重写？

发生继承
方法名同名
参数列表要一模一样 (顺序个数类型)
子类的返回值类型<=父类的返回值类型(引用) 基本类型一模一样
子类的修饰符>=父类的修饰符 (父类中的修饰符不能是private)
子类抛出的异常<=父类抛出的异常 (理解：可以认为任意一个方法都会对外抛出运行时异常)
参一反小修大异小

代码示例

public class Test01 {
	public static void main(String[] args) {
		
	}
}
class F{
	F fun(F s) {
		System.out.println(1/0);
		return null;
	}
}
class S extends F{
	@Override
	public S fun(F s)throws NullPointerException{
		return null;
	}
}