常用类介绍

最新推荐文章于 2023-02-01 15:34:00 发布

sinat_33438008

最新推荐文章于 2023-02-01 15:34:00 发布

阅读量642

点赞数

分类专栏： Java笔记文章标签： java 压力测试开发语言

本文链接：https://blog.csdn.net/sinat_33438008/article/details/123460311

版权

Java笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

String类

String类不能被继承
String创建好之后值是不可以被改变的，这里指的是在堆中的字符串的值是不可以被改变。

 public static void main(String[] args) {
        String s = "monkey";
        change(s);
        System.out.println("main:" + s);//monkey
    }

    public static void change(String s) {
        s = "good";
        System.out.println("change:" + s);
    }

在堆中创建出来的字符串”monkey”是不能被改变的，如果要修改，系统会在堆中重新开辟内存空间将”good”放入，然后将change方法中的s重新引用这个新的内存地址上的”good”。

    String s1 = "monkey";//这种写法会利用字符串常量池，减少内存的使用
    String s2 = "monkey";
    String s3 = new String("monkey");
    String s4 = new String("good");


    System.out.println(s1 == s2);//true s1和s2的内存地址相同
    System.out.println(s1 == s3);//false
    System.out.println(s1.equals(s3));//true

上面代码中，创建s1时，字符串常量池中还不存在堆中monkey的引用,因此jvm会在常量池中创建一个引用指向堆中的这个字符串对象，创建s2时，jvm会去常量池中搜索，此时常量池中有monkey的引用，所以就不创建了，直接让s2指向之前创建的monkey，所以s1和s2指向的是同一个堆内存中的对象。
创建s3时，因为使用了new关键字，所以会在堆中开辟一块内存地址将其放入，s3指向这个新的内存地址，所以s3和s1指向的不是同一个内存地址。
创建s4时，使用了new关键字，会在堆中开辟一块内存地址，s4指向这个内存地址，然后字符串常量池中没有指向good的引用，所以会再重新开辟一块空间，将good放入，然后在字符串常量池中指向这个地址。

开发中建议使用String s = “monkey1024”;这种方式创建字符串对象，可以减少堆内存的使用。

注意：比较两个字符串是否一致最好使用equals方法

例：

统计一个字符串里面另一个字符串出现的次数，例如统计"monkey"在"I am monkey1024.monkey like banana.little monkey is smart."中出现的次数
思路：通过indexOf方法在大的字符串中查找小字符串的索引值，找到后将这个索引值和小字符串的长度相加，之后将大的字符串截取根据相加的结果截取子串，然后继续在剩下的字符串中查找小字符串的索引值，直到索引值返回-1为止

public static void main(String[] args) {
        String src = "I am monkey1024.monkey like banana.little monkey is smart.";
        String dest = "monkey";
        //定义出现的次数
        int count = 0;

        //定义索引值
        int index = 0;


        while((index = src.indexOf(dest)) != -1){
            count++;
            //将src截取子串
            src = src.substring(index + dest.length());
        }

        System.out.println("出现的次数是：" + count);
    }

StringBuffer和StringBuilder

不要频繁的对字符进行拼接操作，例如下面代码：

 String str = "";

    for (int i = 0; i < 100; i++) {
        str += i;//str = str + i; 造成内存空间的浪费
    }

    System.out.println(str);

每次对字符串修改，底层都会重新开辟新的堆内存空间，这样会开辟很多个空间地址，造成浪费。

如果需要对字符串进行频繁拼接的话，建议使用StringBuffer或者StringBuilder，两者的使用方法一致
StringBuffer的底层是byte数组（jdk9之后），jdk8中底层是char数组，如果没有明确设定，则系统会默认创建一个长度为16的byte类型数组，在使用时如果数组容量不够了，则会通过数组的拷贝对数组进行扩容，所以在使用StringBuffer时最好预测并手动初始化长度，这样能够减少数组的拷贝，从而提高效率。

 //创建对象
    //StringBuffer sb = new StringBuffer();//底层会创建一个长度是16的byte数组
    StringBuffer sb = new StringBuffer(300);//底层会创建一个长度是300的byte数组,对数据长度进行预估

    for (int i = 0; i < 100; i++) {
        sb.append(i);//拼接操作
    }

    System.out.println(sb);

包装类

Java里面8个基本数据类型都有相应的类，这些类叫做包装类。
可以在对象中定义更多的功能方法操作该数据，方便开发者操作数据，例如基本数据类型和字符串之间的转换。

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

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a = Integer.MAX_VALUE;
		System.out.println(a);
		
		//创建Integer对象：
		//传入int类型，会将int类型转换为Integer类型：
		Integer a1 = new Integer(a);
		System.out.println(a1.getClass());//class java.lang.Integer
		
		//传入String类型，会将String类型的”22″转换为Integer类型
		String s = "22";
		Integer a2 = new Integer(s);
		//如果传入的字符串不是数字，将会报出NumberFormatException
		//Integer a2 = new Integer("s");//java.lang.NumberFormatException: For input string: "s"
		System.out.println(a2);
		System.out.println(a2.getClass());//class java.lang.Integer
		
		
		//int–>Integer
		Integer i1 = Integer.valueOf(10);
		//Integer–>int
		int i2 = i1.intValue();
		int ai = Integer.valueOf(10);//将Integer类型转换为int类型
		//String–>Integer
		Integer i3 = Integer.valueOf("10");
		//Integer–>String
	    String s1 = i3.toString();
	    //String–>int
		int count = Integer.parseInt("10");//将String类型转换为int类型，传入的字符串必须是数字字符串
		//int–>String
	    String s2 = 10 + "";
	}
}

拆箱装箱和整型缓存

自动装箱：把基本类型转换为包装类类型
Integer i1 = 10;
自动拆箱：把包装类类型转换为基本类型

在判断两个Integer类型是否相等时，要使用equals方法，不能使用”==”，Integer已经重写了Object中的equals方法。

Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3==i4);//false

Integer i3 = new Integer(128);
Integer i4 = new Integer(128);

System.out.println(i3==i4);//false

如果Integer的值是在[-128~127]之间，这些值会从Integer中的“整型缓存池”获取。

Integer i5 = 127; 
Integer i6 = 127;

System.out.println(i5 == i6); //true

上面程序不会在堆中新建对象，会直接从整型常量池中拿

日期类型

获取毫秒数

public class DateTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		long now = System.currentTimeMillis();//获取毫秒数
		System.out.println(now);
		
		String s = "";
		StringBuffer  sb = new StringBuffer (200);
		long before = System.currentTimeMillis();
		for(int i= 1;i<100;i++) {
			//sb.append(i);
			//s+=i;
		}
		long after = System.currentTimeMillis();
		System.out.println(after-before);
	}

}

获取系统当前时间

// 获取系统当前时间
		Date d = new Date();
		System.out.println("今天是" + d.getDate() + "号 现在是：" + d.getHours() + "时" + d.getMinutes() + "分");
		// 今天是14号 现在是：9时24分
		System.out.println(d);// Mon Mar 14 09:24:37 CST 2022
		Date d0 = new Date(0);// 如果构造方法中参数传为0代表的是1970年1月1日
		System.out.println(d0);//Thu Jan 01 08:00:00 CST 1970

日期格式化类

在java.text包下有个SimpleDateFormat类，通过这个类可以将日期修改为我们想要的风格
y表示年 M表示月 d表示日 H表示小时 m表示分钟 s表示秒 S表示毫秒

//日期格式化
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		System.out.println(sdf);//java.text.SimpleDateFormat@c39f0e2
		String date = sdf.format(d);
		System.out.println(date);//2022年03月14日 09:30:07 812

将String类型转换为Date类型

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest02 {
	public static void main(String[] args) {
		String s = "2001年3月3日  12:12:12";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss");
		
		Date d = new Date();
		try {
			d = sdf.parse(s);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(d);//Sat Mar 03 12:12:12 CST 2001
		System.out.println(sdf.format(d));//2001年03月03日  12:12:12
	}
}

Calendar简介

//Calendar
		Calendar c = Calendar.getInstance();
		System.out.println(c.get(Calendar.DAY_OF_WEEK));

enum

public class enmuTest {
	public class DayDemo {

		public static final String SPRING = "spring";

		public static final String SUMMER = "summer";

		public static final String AUTUMN = "autumn";

		public static final String WINTER = "winter";

	}

	public enum Season {
		Spring, Summer, Autumn, Winter
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Season.Summer);

	}
}

Random

双色球实例

import java.util.Arrays;
import java.util.Random;

public class RandomTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Random r = new Random();
//		int i = r.nextInt(22);
//		System.out.println(i);
		
		boolean[] isUsed = new boolean[33];//初始化为false
		int[] result = new int[6];
		System.out.println(isUsed[22]);
		int length = 0;
		while(length<6) {
			int red = r.nextInt(33);
			if(isUsed[red]==false) {
				isUsed[red]=true;
			}else {
				continue;
			}
			result[length++] = red;
			
		}
		Arrays.sort(result);
		for(int i = 0;i<length;i++) {
			System.out.print(result[i]+" ");
		}
		int blue = r.nextInt(15);
		System.out.println("\n"+blue);
	}

}

sinat_33438008

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用类介绍

String类String类不能被继承String创建好之后值是不可以被改变的，这里指的是在堆中的字符串的值是不可以被改变。 public static void main(String[] args) { String s = "monkey"; change(s); System.out.println("main:" + s);//monkey } public static void change(String s) {
复制链接

扫一扫