Day16-C:\Users\Lenovo\Desktop\note\code\JavaSE\Basic\src\com\classlei

Random()

java.lang.Math.Random

调用这个Math.Random()能返回带正号的double值，该值[0.0,1.0)，该返回值是一个伪随机选择的数，在该范围内近似均匀分布

public class random {
    public static void main(String[] args) {
        System.out.println("Math.Random()="+Math.random());
        int num =(int) (Math.random()*3);//Math.random()返回值是double所以要强制转换
        System.out.println("num="+num);//结果为0或1
    }
}

java.util.Random

import java.util.Random;

public class random {
    public static void main(String[] args) {
        System.out.println("Math.Random()="+Math.random());
        int num =(int) (Math.random()*3);//Math.random()返回值是double所以要强制转换
        System.out.println("num="+num);
        Random random = new Random();
        int i = random.nextInt(1000);//边界为1000，生成一个[0,1000)的整数
        System.out.println("i="+i);
        Random rand = new Random(10);
        for(int j=0;j<10;j++){
            System.out.println(rand.nextInt(100));
        }
        System.out.println();//最后额外输出一个空行
    }
}

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

Random(long seed):使用单个long种子创建一个新的随机数生成器，对于种子相同的Random对象，生成的随机数序列是一样的

Date()

Date()提供了两个构造函数来实例化Date对象

构造函数使用当前日期和时间来初始化对象
构造函数接收一个参数，该参数是自1970年1月1日起的毫秒数

import java.util.Date;//不建议
import java.time.LocalDateTime;//建议使用这个

public class date {
    public static void main(String[] args) {
        Date currentdate = new Date();//import java.util.Date;初始化Date对象
        //date date = new date();
        System.out.println(currentdate);
        System.out.println(currentdate.getTime());//返回毫秒值
        System.out.println(currentdate.getTime()-8640000);//返回毫秒值
        Date pastDate = new Date(System.currentTimeMillis() - 86400000);// 一天前的时间（86400000毫秒=1天）
        //System.currentTimeMillis() 用于获取当前系统时间的毫秒数（时间戳，从 1970 年 1 月 1 日 00:00:00 UTC 开始计算）。
        boolean isafter = pastDate.after(currentdate);//布尔值比较，返回布尔值对Date类的pastDate使用after方法
        System.out.println(isafter);
    }
}

Calendar()

public class Calendar {
    static java.util.Calendar calendar= java.util.Calendar.getInstance();
    static java.util.Calendar calendar1= java.util.Calendar.getInstance();


    public static void main(String[] args) {
        SimpleDateFormat d = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");//实例化SimpleDateFormat，简便日期格式类
        System.out.println(d.format(calendar.getTime()));//调用简便日期格式类中的format方法
        System.out.println(Calendar.calendar);
        calendar1.set(2025,10,18);
        System.out.println(calendar1);
    }
}

String()

String str = "hello"直接赋值法创建对象在方法区的常量池

String str1= new String(“hello”)通过构造方法创建字符对象储存在堆内存

str储存在在栈内存中，hello储存在堆内存中

public class Stringg {
    public static void main(String[] args) {
        java.lang.String str1 = "David";//只开辟一块内存空间，自动入池，不产生垃圾，享元模式
        java.lang.String str2 = new java.lang.String("David");//开辟两块堆内存空间，其中一块变成垃圾，且不能自动入池，需要通过public String intern();入池
        java.lang.String str3 = str2;
        java.lang.String str4 = "David";
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str2==str3);
        System.out.println(str1==str4);
        System.out.println("=============");
        System.out.println(str1.equals(str2));//Object类中的equals是比较地址的，但是String类重写了之后仅比较内容
        String str5 = "1,2,3,4";
        String[] str6 = str5.split(",");
        for (String str7 : str6) {//for-each循环遍历打印
            System.out.println(str7);
        }
        String str8 = new java.lang.String("Davis");
        //创建了两个对象
        //首先出现了字面量“Davis”，先去String Pool中查找是否有相同字符串存在，由于该程序只有一行，自然是没有的，那么会在Java Heap中用字面量"hello"创建一个String对象
        //接着new java.lang.String("Davis")，关键字new有在Java Heap中创建了一个对象，然后调用接收String参数的构造器进行了初始化，最终引用这个对象


    }
}

String Builder和StringBuffer

String Builder和StringBuffer都继承了AbstractStringBuilder，前者是非线程安全的，后者是线程安全的。都是可变的字符串容器，可以直接在原有对象上修改内容（如拼接、插入、删除等），避免频繁创建新对象，从而提升性能。

public class StringBuilderandStringBuffer {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");       // 拼接："Hello"
        sb.append(" ");           // 拼接："Hello "
        sb.append("World");       // 拼接："Hello World"
        sb.insert(6, "Java ");    // 插入："Hello Java World"
        sb.delete(5, 6);          // 删除空格："HelloJava World"
        sb.reverse();             // 反转："dlroW avaJolleH"
        String result = sb.toString();  // 转为String："dlroW avaJolleH"
        System.out.println(result);

        StringBuffer sb2 = new StringBuffer("Hello");
        sb2.append("World");
        sb2.insert(5, "Java ");//5这个位置插入Java后，将后面的字符串后移（从0位开始）
        sb2.insert(5, new StringBuffer("fucking"),0,7);//在5位将fucking从0位到6位插入，左闭右开
        System.out.println(sb2.toString());
        sb2.replace(5,12,"nb");//将5到11位替换为nb
        System.out.println(sb2.toString());
        sb2.delete(5,7);//将5到6位删除
        System.out.println(sb2.toString());
        sb2.reverse();
        String result2 = sb2.toString();
        System.out.println(result2);
        StringBuilder hello = new StringBuilder("Hello Java!I love you!");
        int i1 = hello.indexOf("Hello");
        System.out.println("Hello首次出现的位置"+i1);
        int i2 = hello.indexOf("love");
        System.out.println("love首次出现的位置"+i2);
        int i3 = hello.indexOf("o",5);
        System.out.println("o从5位开始首次出现的位置"+i3);
        int i4 = hello.indexOf("o");
        System.out.println("o首次出现的位置"+i4);
        int i5 = hello.indexOf("Python");
        System.out.println("Python首次出现的位置"+i5);//-1
        int i6 = hello.lastIndexOf("o");
        System.out.println("o从后往前数首次出现的位置"+i6);//19

    }

}

在 Java 中，indexOf() 是字符串（String）、StringBuilder、StringBuffer 等类中用于查找指定字符或子字符串首次出现位置的方法，类似地还有 lastIndexOf() 用于查找最后一次出现的位置。

速度上StringBuilder>StringBuffer>String

posted @ 2025-10-17 20:29 David大胃阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

David0919