Java常用类
1、包装类
/** 知识点：包装类
含义：Java为每种基本数据类型分别匹配的类
出现原因：Java为纯面向对象语言，一切皆对象，8种基本数据类型不能创建对象，就破坏了Java为纯面向对象语 言的特征，所以Java为8种基本数据类型都分别匹配了对应的类，这种类 我们叫做包装类/封装类
基本数据类型 包装类 继承关系
byte Byte Object.Number.Byte
short Short Object.Number.Short
int Integer Object.Number.Integer
long Long Object.Number.Long
float Float Object.Number.Float
double Double Object.Number.Double
char Character Object.Character
boolean Boolean Object.Boolean
注意：int和char类型对应的包装类Integer和Character，其余的都是首字母大写
应用场景之一：集合类似于数组，也是存放数据的容器，但是集合只能存放引用数据类型，如果想要存储基本数据 类型，就存储基本数据类型对应的包装类对象
*/
public class Test01{
public static void main(String[]args){
//手动装箱：基本数据类型转包装类
int i = 100;
Integer integer = Integer.valueOf(i);
System.out.println(integer);
//手动拆箱：包装类转基本数据类型
Integer integer = new Integer(100);
int i = integer.intValue();
System.out.println(i);
//JDK1.5的新特性：自动装箱 和 自动拆箱
//自动装箱：基本数据类型转包装类
int i = 100;
Integer integer = i; //底层：Integer.valueOf(i);
System.out.println(integer);
//自动拆箱：包装类转基本数据类型
Integer integer = new Integer(100);
int i = integer; //底层：integer.intValue();
System.out.println(i);
//将字符串转换为int值
String str = "123";
int value = Integer.valueOf(str);
System.out.println(value);
}
}
public class Test02 {
public static void main(String[] args) {
/**
* 知识点：包装类面试题
*
* 前言：Integer底层有个缓存数组，缓存数组中存储了-128~127的Integer对象
*/
Integer integer1 = Integer.valueOf(100);//从缓存数组中获取Integer对象
Integer integer2 = Integer.valueOf(100);//从缓存数组中获取Integer对象
System.out.println(integer1 == integer2);//true
Integer integer3 = Integer.valueOf(200);//新建Integer对象
Integer integer4 = Integer.valueOf(200);//新建Integer对象
System.out.println(integer3 == integer4);//false
}
}
2、String、StringBuilder、StringBuffer类
2.1 String类
public class Test01{
public main void main(String[]args){
/**
* 知识点：String类的使用
*
* 前言：String的底层是将字符串分解成字符数组
*/
String str = "123abc";
str = str.concat("DEF123"); //在此字符串末尾追加子字符串，并返回新的字符串
str = str.substring(2); //从开始下标处截取到字符串末尾，并返回新的字符串
str = str.substring(1,7); //从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
str = str.toLowerCase(); //转小写，并返回新的字符串
str = str.toUpperCase(); //转大写，并返回新的字符串
str = " 123 ab c DEF 11 234557755 ";
str = str.trim(); //去掉首尾空格，并返回新的字符串
str = str.replace('7', 'x'); //替换字符，并返回新的字符串
str = str.replaceFirst("23", "彭于晏"); //替换第一次出现的字符串，并返回新的字符串
str = str.replaceAll("55", "吴彦祖"); //替换字符串，并返回新的字符串
str = str.replaceAll(" ", ""); //去空格
System.out.println("判断字符串是否以某个字符串开头：" + str.startsWith("1彭于晏")); //true
System.out.println("判断字符串是否以某个字符串结尾：" + str.endsWith("吴彦祖")); //true
System.out.println("判断两个字符串是否相同(区分大小写)：" + str.equals("1彭于晏abcDEF11234吴彦祖xx吴彦祖")); //true
System.out.println("判断两个字符串是否相同(不区分大小写)：" + str.equalsIgnoreCase("1彭于晏ABCdef11234吴彦祖xx吴彦祖")); //true
System.out.println("查找子字符串在此字符串中第一次出现的下标：" + str.indexOf("吴彦祖"));
System.out.println("查找子字符串在此字符串中最后一次出现的下标：" + str.lastIndexOf("吴彦祖"));
System.out.println("获取指定下标上的字符：" + str.charAt(4));
System.out.println("获取字符串的长度：" + str.length());
System.out.println(str);//1彭于晏abcDEF11234吴彦祖xx吴彦祖
//valueOf -- String类的静态方法
//含义：将其他数据类型转换为String类型
System.out.println(String.valueOf(100));
System.out.println(String.valueOf(123.123));
System.out.println(String.valueOf('a'));
System.out.println(String.valueOf(true));
//将其他数据类型转换为String类型 的简便方法
System.out.println(100 + "");
System.out.println(123.123 + "");
System.out.println('a' + "");
System.out.println(true + "");
}
}
2.2 StringBuilder类
public class Test03 {
public static void main(String[] args) {
/**
* 知识点：StringBuilder类
*
* StringBuilder代表可变的字符序列（字符串）。
* StringBuilder称为字符串缓冲区，
* 它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
* StringBuilder是可变对象，这个是String最大的不同
*
* 继承关系：
* public abstract class AbstractStringBuilder{
* char[] value;
* }
* public final class StringBuilder extends AbstractStringBuilder{}
*/
//创建StringBuilder的对象，默认创建16个长度的字符数组
//StringBuilder sb = new StringBuilder();
//创建StringBuilder的对象，自定义字符数组的长度
//StringBuilder sb = new StringBuilder(100);
//创建StringBuilder的对象，长度为："123abc".length() + 16
StringBuilder sb = new StringBuilder("123abc");
sb.append("DEF123");//在末尾追加字符串
sb.insert(3, "xxxyyyzzz");//在指定下标上插入字符串
sb.setCharAt(4, 'X');//替换指定下标上的字符
sb.deleteCharAt(4);//删除指定下标上的字符
sb.delete(3, 11);//删除开始下标处(包含)到结束下标处(不包含)的字符串
sb.reverse();//反转字符串
System.out.println(sb);//321FEDcba321
/**
* StringBuffer vs StringBuilder
*
* 相同点：这两个类都是继承 AbstractStringBuilder，所有的数据都是存储在父类中的char[] value里
*
* StringBuffer：线程安全的（上锁、解锁），多线程的情况下使用
* StringBuilder：线程不安全的（没有上锁、没有解锁），单线程的情况下使用，效率更高
*
* StringBuffer底层源码
* class StringBuffer extends AbstractStringBuilder{
* //线程安全的方法 -- synchronized
* public synchronized void append(String str){//上锁
* super.appen(str);
* }//解锁
* }
*
* StringBuilder底层源码
* class StringBuilder extends AbstractStringBuilder{
* public void append(String str){
* super.appen(str);
* }
* }
*
*/
//注意：频繁拼接字符串使用StringBuilder或StringBuffer
}
}
public class Test04 {
public static void main(String[] args) {
/**
* 知识点：深入String面试题
*
* 注意：常量池里的数据不允许重复
*
*/
//以下代码创建几个字符串对象？
//1个
// String str1 = "abc";
// String str2 = "abc";
// System.out.println(str1 == str2);//true
//以下代码创建几个字符串对象？
//3个（“abc”、new了两个String）
// String str1 = new String("abc");
// String str2 = new String("abc");
// System.out.println(str1 == str2);//false
//String底层的字符数组为什么使用final修饰？
//String是一个不可变的字符串类型，既一个String对象创建成功后，包含在该对象中的字符串是不可变的
String str = "abc";
str = "abcd";
}
}
public class Test05 {
public static void main(String[] args) {
/**
* 知识点：深入String创建对象的问题
*
*/
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);//true
//两个常量在编译时直接拼接
String str3 = "ab" + "c";//编译——> String str3 = "abc";
System.out.println(str1 == str3);//true
//两个常量在编译时直接拼接
final String s1 = "ab";
final String s2 = "c";
String str4 = s1 + s2;//编译--> String str4 = "abc";
System.out.println(str1 == str4);//true
//两个变量在编译时会创建StringBuilder对象
String s3 = "ab";
String s4 = "c";
String str5 = s3 + s4;//编译--> String str5 = new StringBuilder(s3).append(s4).toString()
System.out.println(str1 == str5);//false
}
}
3、正则表达式
public class Test01 {
public static void main(String[] args) {
String str = "小红15111111234 小绿13922221234 张三22222222222";
String regex = "(1\\d{2})(\\d{4})(\\d{4})";
str = str.replaceAll(regex, "$1恭喜发财$3");
System.out.println(str);
}
}
public class Test02 {
public static void main(String[] args) {
String str = "1445584980@qq.com";
String regex = "\\d{6,11}@qq.com";
boolean bool = str.matches(regex);
System.out.println(bool);
}
}
public class Test03 {
public static void main(String[] args) {
String str = "c:\\资源\\日本\\结衣.avi";
String regex = ":?\\\\";
String[] ss = str.split(regex);
for (String s : ss) {
System.out.println(s);
}
}
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test04 {
public static void main(String[] args) {
String str = "<img src='hhy/aaa.jpg'/><div><div/> <input type='image' src='submit.gif' /><img src='bbb.jpg'/>";
String regex = "<img\\b[^>]*\\bsrc\\b\\s*=\\s*('|\")?([^'\"\n\r\f>]+(\\.jpg|\\.bmp|\\.eps|\\.gif|\\.mif|\\.miff|\\.png|\\.tif|\\.tiff|\\.svg|\\.wmf|\\.jpe|\\.jpeg|\\.dib|\\.ico|\\.tga|\\.cut|\\.pic)\\b)[^>]*>";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
while(matcher.find()){
String group = matcher.group(2);
System.out.println(group);
}
}
}
4、日期时间类
import java.util.Date;
public class Test01 {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
}
}
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test02 {
public static void main(String[] args) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String str = sdf.format(new Date());
System.out.println(str);
}
}
import java.util.Calendar;
public class Test03 {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
System.out.println(year);
System.out.println(month);
System.out.println(day);
System.out.println(hour);
System.out.println(minute);
System.out.println(second);
}
}
5、math-数学类
public class Test01 {
public static void main(String[] args) {
System.out.println("求次方：" + Math.pow(3, 2));
System.out.println("求平方根：" + Math.sqrt(9));
System.out.println("求绝对值：" + Math.abs(-100));
System.out.println("向下取整(地板)：" + Math.floor(1.9));
System.out.println("向上取整(天花板)：" + Math.ceil(1.1));
System.out.println("四舍五入：" + Math.round(1.4));
System.out.println("求最大值：" + Math.max(10, 20));
System.out.println("求最小值：" + Math.min(10, 20));
System.out.println("求随机值0(包含)~1(不包含)：" + Math.random());
int num = (int)(Math.random()*100)+1;
System.out.println("随机出1~100的数组：" + num);
}
}
public class Test02 {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println("求绝对值：" + Math.abs(Integer.MAX_VALUE+1));
System.out.println("求绝对值：" + Math.abs(Integer.MIN_VALUE));
}
}
import static java.lang.Math.*;
public class Test03 {
public static void main(String[] args) {
System.out.println("求次方：" + pow(3, 2));
System.out.println("求平方根：" + sqrt(9));
System.out.println("求绝对值：" + abs(-100));
}
public static int abs(int i){
return -1234;
}
}
6、Random类
import java.util.Random;
public class Test01 {
public static void main(String[] args) {
Random ran = new Random();
int num1 = ran.nextInt();
System.out.println(num1);
int num2 = ran.nextInt(10);
System.out.println(num2);
double num3 = ran.nextDouble();
System.out.println(num3);
boolean bool = ran.nextBoolean();
System.out.println(bool);
}
}
import java.util.Random;
public class Test02 {
public static void main(String[] args) {
String[] names = {"罗菌","严智","杜亚","陈姝","李林","申华"};
Random ran = new Random();
int index = ran.nextInt(names.length);
System.out.println(names[index]);
}
}
import java.util.Random;
public class Test03 {
public static void main(String[] args) {
Random ran = new Random(100);
System.out.println(ran.nextInt());
}
}
7、runtime类
public class Test01 {
public static void main(String[] args) {
Runtime run = Runtime.getRuntime();
System.out.println("获取处理数：" + run.availableProcessors());
System.out.println("获取最大内存数(字节)：" + run.maxMemory());
System.out.println("获取闲置内存数(字节)：" + run.freeMemory());
}
}
8、大数值运算
import java.math.BigInteger;
public class Test01 {
public static void main(String[] args) {
BigInteger big1 = new BigInteger("12000000000");
BigInteger big2 = new BigInteger("12000000000");
BigInteger add = big1.add(big2);
System.out.println("加法：" + add);
BigInteger subtract = big1.subtract(big2);
System.out.println("减法：" + subtract);
BigInteger multiply = big1.multiply(big2);
System.out.println("乘法：" + multiply);
BigInteger divide = big1.divide(big2);
System.out.println("除法：" + divide);
}
}
import java.math.BigDecimal;
public class Test02 {
public static void main(String[] args) {
BigDecimal big1 = new BigDecimal("0.5");
BigDecimal big2 = new BigDecimal("0.4");
BigDecimal add = big1.add(big2);
System.out.println("加法：" + add);
BigDecimal subtract = big1.subtract(big2);
System.out.println("减法：" + subtract);
BigDecimal multiply = big1.multiply(big2);
System.out.println("乘法：" + multiply);
BigDecimal divide = big1.divide(big2);
System.out.println("除法：" + divide);
}
}
import java.math.BigDecimal;
public class Test03 {
public static void main(String[] args) {
BigDecimal big1 = new BigDecimal("10");
BigDecimal big2 = new BigDecimal("3");
BigDecimal divide = big1.divide(big2, 3, BigDecimal.ROUND_HALF_UP);
System.out.println("除法：" + divide);
}
}
9、System
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
InputStream in = System.in;
Scanner scan = new Scanner(in);
String str = scan.next();
scan.close();
PrintStream err = System.err;
err.println(str);
}
}
public class Test02 {
public static void main(String[] args) {
System.out.println("小明");
System.err.println("小红");
System.out.println("小强");
}
}
import java.util.Properties;
public class Test03 {
public static void main(String[] args) {
Properties properties = System.getProperties();
System.out.println(properties);
String value = System.getProperty("os.name");
System.out.println(value);
}
}
import java.util.Arrays;
public class Test04 {
public static void main(String[] args) {
int[] is = {1,2,3,4,5,6,7,8,9};
System.arraycopy(is, 3, is, 2, 6);
is[is.length-1] = 0;
System.out.println(Arrays.toString(is));
}
}
10、枚举类
public enum Season{
spring("春天","春雨绵绵"),
summer("夏天","烈日炎炎"),
autumn("秋天","硕果累累"),
winter("冬天","银装素裹");
private String name;
private String info;
private Season() {
}
private Season(String name, String info) {
this.name = name;
this.info = info;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Season [name=" + name + ", info=" + info + "]";
}
}
public class Test01 {
public static void main(String[] args) {
System.out.println(Season.spring);
System.out.println(Season.summer);
System.out.println(Season.autumn);
System.out.println(Season.winter);
}
}
public enum Signal {
RED,YELLOW,GREEN;
}
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请选择信号灯：RED，YELLOW，GREEN");
String str = scan.next();
scan.close();
Signal signal = Signal.valueOf(str);
String trafficInstruct = getTrafficInstruct(signal);
System.out.println(trafficInstruct);
}
public static String getTrafficInstruct(Signal signal){
String instruct = "信号灯故障";
switch (signal) {
case RED:
instruct = "红灯停";
break;
case YELLOW:
instruct = "黄灯请注意";
break;
case GREEN:
instruct = "绿灯行";
break;
}
return instruct;
}
}
扫一扫
1034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
