【入坑Java第六天】

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量224 收藏
点赞数 1
分类专栏： 入坑Java 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44830111/article/details/126382900
版权

常用类

String类

  • String是引用数据类型，不属于基本数据类型，"hello world"不是基本类型，而是一个String对象。通过String源码中public final char[] value，这个value属性是一个char数组，所以字符串底层实际上是一个字符数组，通过final说明，字符串一旦被创建是不可变的。

  • 以下程序创建了几个String对象：

    public class Test{
    String s1 = "hello";
    String s2 = "hello";
    String s3 = new String("hello");
    String s4 = new String("hello");
}

    双引号括起来的“hello”一定会在字符串常量池中创建并保存一个。一旦使用new关键字必然会在堆内存中开辟新的存储空间，以上程序new了两次。以上程序一共有三个对象，堆内存中两个，字符串常量池中一个（实际上三个对象都在堆内存中，因为Java8之后字符串常量池挪到了堆内存中）。

  • 字符串拼接：

    public class Test{
    String s1 = "hello";
    String s2 = "world";
    String s3 = s1 + s2;
    String s4 = "abc" + "def";
}

    通过加号可以进行字符串的拼接，字符串一旦被创建不可变，以上程序一共6个对象都保存在字符串常量池中。

    接下来通过一个程序看看有多少对象：

    public class Test {
    public static void main(String[] args) {
        String s = "";
        for (int i=0;i<10000;i++){
            s += i;
        }
    }
}

    如果加号两边都是字符串常量的话，可以使用加号进行拼接，因为它们会在编译阶段拼接。但如果加号两个有变量的话，必然会在底层new一共StringBuilder对象进行字符串的拼接，如果循环拼接的话，每次循环都会new一共StringBuilder对象，所以效率较低。通过上面程序的循环可以猜到nwe了一万个对象StringBuilder对象，效率较低。怎么解决呢？在for循环外面创建一个StringBuilder对象，在for循环中调用StringBuilder的append方法进行字符串的拼接，这样只创建了一共StringBuilder对象，效率较高。如果字符串需要进行频繁拼接，建议使用StringBuilder对象。

  • 字符串的比较

    public class Test{
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);
    }
}
​
运行结果：
false

    双等号判断的是内存的地址，以上程序new了两次，所以是两个不同的内存地址，所以双等号判断结果是false。

    在String类中有一共方法可以进行字符串的比较：equals()方法。

    public class Test{
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1.equals(s2));
    }
}
​
运行结果：
true

    通过以上程序可以得出，进行字符串比较使用equals()方法，equals()方法底层实际上也是双等号比较地址，但String类进行了重写比较的是内容。

  • String的构造方法：

    String(String original);
String(byte[] bytes); // 将byte数组转成字符串
String(byte[] bytes , int offset , int length); // 将byte数组的一部分转成字符串
String(char[] value); // 将char数组转成字符串
String(char[] value , int offset , int length); // 将char数组的一部分转成字符串

    以下代码进行测试：

    public class Test {
    public static void main(String[] args) {
​
        // 1
        String s1 = "hello";
​
        // 2
        String s2 = new String("world");
​
        //3
        byte[] bytes = {97,98,99,100};
        String s3 = new String(bytes);
        String s4 = new String(bytes,0,2);
​
        // 4
        char[] chars = {'你','好','呀'};
        String s5 = new String(chars);
        String s6 = new String(chars,0,2);
​
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s5);
        System.out.println(s6);
    }
}
​
运行结果：
hello
world
abcd
ab
你好呀
你好  

  • String类的常用方法

    char charAt(int index); 
// 返回指定索引index的字符
​
int compareTo(String anotherString); 
// 比较两个字符串大小，a.compareTo(b),结果0表示a和b相等，结果<0表示a<b，结果>0表示a>b
​
String concat(String str);
// 拼接字符串，参数只能是String类型，如果参数是null，会出现空指针异常
​
boolean contains(CharSequence s);
// 判断当前字符串是否包含某个字符串s
​
boolean endsWith(String sufffix);
// 判断当前字符串是否以某个字符串结尾
​
boolean equals(Object anObject);
// 判断两个字符串是否相等
​
boolean equalslgnoreCase(String anotherString);
// 判断两个字符串是否相等，忽略大小写
​
byte[] getBytes();
// 将字符串转成byte数组
​
int indexOf(String str);
// 获取str字符串在当前字符串中第一次出现的索引
​
int indexOf(String str , int frimlndex);
// 从下标frimlndex开始，获取str字符串在当前字符串中第一次出现的索引
​
int lastlndexOf(String str);
// 获取str在当前字符串中最后一次出现的索引
​
int lastlndexOf(String str , int frimlndex);
// 从下标frimlndex开始，获取str在当前字符串中最后一次出现的索引
​
String intern();
// 从字符串常量池中获取当前字符串对象，获取则返回，如果获取不到，则新建一共字符串常量存储常量池中，并返回此字符串的引用
​
int length();
// 获取字符串的长度
​
String replaceAll(String str,String newStr);
// 将字符串str替换成newStr
​
String[] split(String regex);
// 将当前字符串对象是否以某个特定的符号进行拆分，返回String数组
​
boolean startsWith(String prefix);
// 判断当前字符串对象是否以某个子字符串开头
​
String substring(int beginlndex);
// 从beginlndex下标开始截取字符串，返回截取后的子字符串
​
String substring(int beginlndex , itn endlndex);
// 从beginlndex下标开始，到endlndex结束（不包括），截取字符串
​
char[] toCharArray();
// 将字符串转成char数组
​
String toLowerCase();
// 转成小写
​
String toUpperCase();
// 转成大写
​
String trim();
// 去除字符串前后空白
​
String strip();
// 去除字符串前后空白，并且支持unicode编码的空白
​
static String valueOf(任意类型的参数);
// 将任意类型的参数转成字符串

StringBuilder与StringBuffer

  • StringBuilder和StringBuffer是对String的一个补充，String称为不可变长字符串，而StringBuilder和StringBuffer称为可边长字符串，它们的区别是：StringBuffer在多线程并发的环境下，它是安全的。而StringBuilder是非线程安全的。其他方面基本相同。

  • StringBuilder主要是进行字符串的拼接，因为String做字符串的拼接使用+号，会在字符串常量池中生成多个String对象，效率较低，而StringBuilder不会。

  • 通过源码解析，StringBuilder底层是一个char[]数组，StringBuilder的默认初始化容量是16，通过构造方法也可以指定初始容量，StringBuilder和StringBuffer称为可边长字符串，那他们是怎么扩容的呢？扩容规则：原数组容量*2+2。

  • 在StringBuilder和StringBuffer中都有一个拼接字符串的方法，append()方法，通过以下程序进行测试：

    public class Test {
    public static void main(String[] args) {
​
        // 创建一个指定初始化容量的StringBuilder对象
        StringBuilder s = new StringBuilder(30);
​
        // 拼接（追加）字符串
        s.append("public class Test{\n");
        s.append("int a = 10");
        s.append("\n}");
​
        System.out.println(s);
​
    }
}
​
运行结果：
public class Test{
int a = 10
}

包装类

  • Java语言中提供了8中基本类型，为了编程方便，对这8中基本类型又分别提供了它们的包装类。

  • 基本数据类型包装类型（java.lang包下）
    byteByte
    shortShort
    intInteger
    longLong
    floatFloat
    doubleDouble
    booleanBoolean
    charCharacter

  • 其中Byte,Short,Integer,Long,Float,Double它们6个的父类是Number，而Boolean和Charcater它们两个的父类是Object。

  • 以下程序测试包装类的拆箱和装箱：

    public class Test {
    public static void main(String[] args) {
​
        // 手动装箱，Integer提供了两个构造方法，可传入数字和字符串（这个字符串必须是一个数字）
        Integer x1 = Integer.valueOf(100);
        Integer x2 = Integer.valueOf("200");
        // 手动拆箱
         int y1 = x1.intValue();
         int y2 = x2.intValue();
        
        // 自动装箱
        Integer a = 500;
        // 自动拆箱
        int b = a;
​
    }
}

  • 这里有一个经典的题，大家可以猜测一下结果是什么：

    public class Test {
    public static void main(String[] args) {
​
        Integer x = 127;
        Integer y = 127;
        System.out.println( x == y);
​
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);
​
    }
}
​
运行结果：
true
false

    第一个结果是true，第二结果是false，这是为什么呢？

    因为在Integer类中有一个特殊的机制，在Integer类进行加载之后，会在堆（Java7之前在方法区）中生成一个整数常量池，这个常量池的范围-128~127，

    也就是说当数字没有超过这个范围的时候，会直接从整数常量池中拿这个Integer对象，如果超出了这个范围才会new对象。x和y没有超出这个范围，它们拿的是同一个对象，而a和b超出了这个范围，它们是new的对象，双等号判断的是内存地址，所以a和b是false。

日期类

  • 日期在实际的开发中应用非常广泛，主要涉及到的类有：java.utilDate , java,text,SimpleDateFormat , java.util.Calendar。

  • 如何获取系统当前时间：

    public class Test {
    public static void main(String[] args) {
​
        // 获取系统当前时间
        Date date = new Date();
​
        // 这里输出date会自动调用toString方法
        System.out.println(date);
​
    }
}
​
运行结果：
Wed Aug 17 10:13:41 CST 2022

  • 通过以上的程序输出当前系统时间，但这个时间格式对于我们来说不太习惯，接下来将日期格式化：

    public class Test {
    public static void main(String[] args) {
​
        // 获取系统当前时间
        Date date = new Date();
​
        /*
            创建格式化日期对象
            y 年
            M 月
            d 日
            H 时
            m 分
            s 秒
            S 毫秒
        */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
        
        // 调用format方法进行格式化，返回一个字符串
        String time = sdf.format(date);
        
        System.out.println(time);
​
    }
}
​
运行结果：
2022/08/17 10:17:31 238

  • 以上代码将日期类型转成String类型，怎么将String类型转成日期类型呢？

    public class Test {
    public static void main(String[] args) {
​
        // 创建一个格式化对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
​
        // 创建一个字符串日期，这个字符串日期格式必须和日期格式化对象格式匹配
        String date = "2008/1/1 19:30:00";
​
        try {
            // 将String类型转成Date类型，使用parse方法，这个方法需要处理异常
            Date newDate = sdf.parse(date);
            System.out.println(newDate);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
​
    }
}
​
运行结果：;
Tue Jan 01 19:30:00 CST 2008

  • 如果我们想获取一个时间对于的星期几，这时候需要借助日历类，例如：

    public class Test {
    public static void main(String[] args) {
​
        // 获取系统当前时间
        Date date = new Date();
​
        // 获取日历对象
        Calendar c = Calendar.getInstance();
​
        // 让日历对象关联时间
        c.setTime(date);
​
        System.out.println("系统当前时间：" + date);
​
        System.out.println("一周的第几天：" + c.get(Calendar.DAY_OF_WEEK));
​
        System.out.println("一个月的第几天：" + c.get(Calendar.DAY_OF_MONTH));
​
    }
}
​
运行结果：;
系统当前时间：Wed Aug 17 10:34:50 CST 2022
一周的第几天：4
一个月的第几天：17

    这个为什么是第四天呢？因为国外的一周第一天是星期日。

数学类

public class Test {
    public static void main(String[] args) {
​
        // java.util.Math 数学工具类
​
        // 计算平方根
        System.out.println("9的平方根：" + Math.sqrt(9));
​
        // 计算立方根
        System.out.println("8的立方根：" + Math.cbrt(8));
​
        // 计算x的y次方
        System.out.println("2的3次方：" + Math.pow(2,3));
​
        // 计算最大值
        System.out.println("1和2的最大值：" + Math.max(1,2));
​
        // 计算最小值
        System.out.println("1和2的最小值：" + Math.min(1,2));
​
        // 计算绝对值
        System.out.println("-1的绝对值：" + Math.abs(-1));
​
        // 向上取整
        System.out.println("10.2向上取整：" + Math.ceil(10.2));
​
        // 向下取整
        System.out.println("10.99向下取整：" + Math.floor(10.99));
​
        // 四舍五入返回double类型
        System.out.println("10.4四舍五入返回double类型：" + Math.rint(10.4));
        System.out.println("10.5四舍五入返回double类型：" + Math.rint(10.5));
​
        // 四舍五入返回int类型
        System.out.println("10.4四舍五入返回int类型：" + Math.round(10.4));
        System.out.println("10.5四舍五入返回int类型：" + Math.round(10.5));
​
    }
}
​
运行结果：
9的平方根：3.0
8的立方根：2.0
2的3次方：8.0
1和2的最大值：2
1和2的最小值：1
-1的绝对值：1
10.2向上取整：11.0
10.99向下取整：10.0
10.4四舍五入返回double类型：10.0
10.5四舍五入返回double类型：10.0
10.4四舍五入返回int类型：10
10.5四舍五入返回int类型：11

数字类

  • 这里主要掌握两个类：java.text.DecimalFormat （数字格式化显示方面）和java.math.BigDecimal（财务数据处理方面）。

    public class Test {
    public static void main(String[] args) {
​
        // 创建数字格式化对象
        // ###,###.## 表示数字加入千分位，保留两位小数
        DecimalFormat df = new DecimalFormat("###,###.##");
        String str = df.format(123456.789);
        System.out.println(str);
​
        // 小数部分保留两位，四舍五入
        DecimalFormat df2 = new DecimalFormat(".00");
        String str2 = df2.format(123.5489);
        System.out.println(str2);
​
    }
}
​
运行结果：;
123,456.79
123.55
    public class Test {
    public static void main(String[] args) {
​
        // 创建两个个精度较高的对象
        BigDecimal v1 = new BigDecimal(100);
        BigDecimal v2 = new BigDecimal(200);
​
        // 求和方法
        BigDecimal x1 = v1.add(v2);
        System.out.println(x1);
​
        // 乘积方法
        BigDecimal x2 = v1.multiply(v2);
        System.out.println(x2);
        
        // 这里只说了求和与乘积的方法，当然还有其他的方法，大家可以去查文档进行学习
​
    }
}
​
运行结果：
300
20000

随机数

public class Test {
    public static void main(String[] args) {
​
        // 在Java中可以专门生成随机数，java.util.Random
​
        // 创建一个随机生成器对象
        Random r = new Random();
        System.out.println("返回一个int类型随机数：" + r.nextInt());
​
        // 生成五个int类型的随机数,范围在0~100之间
        for (int i=0;i<5;i++){
            int v = r.nextInt(100);
            System.out.print(v + " ");
        }
​
        System.out.println();
​
        // 生成五个int类型的随机数,范围在0~10之间
        for (int i=0;i<5;i++){
            int v = r.nextInt(6);
            System.out.print(v + " ");
        }
​
    }
}
​
运行结果：;
返回一个int类型随机数：-178658592
40 1 65 55 75 
2 2 5 2 1

  • 通过以上程序发现，区间越小，重复也高。假设现在有一个需求，在0~4之间生成5个不同的随机数，这应该怎么去实现呢？

    public class Test {
    public static void main(String[] args) {
​
        // 创建随机生成器对象
        Random random = new Random();
​
        // 准备一个容量为5的int类型的数组
        // 元素初始值为-1，如果为0的话，随机数中可以能有0，可能程序出错
        int[] arr = new int[]{-1,-1,-1,-1,-1};
​
        // 从数组的第一个下标开始放元素
        int index = 0;
        while (index < arr.length){
            // 生成随机数
            int value = random.nextInt(5);
            // 如果数组中不包含随机数，放进数组中
            if (!(query(arr,value))){
                arr[index++] = value;
            }
        }
​
        // 输出结果
        System.out.println(Arrays.toString(arr));
    }
​
    /**
     * 查询数组中是否包含value随机数
     * @param arr 数组
     * @param value 查询元素
     * @return true包含 ， false不包含
     */
    public static boolean query(int[] arr , int value){
        for (int i=0;i<arr.length;i++){
            if (arr[i] == value){
                return true;
            }
        }
        return false;
    }
​
}
​
运行第一次结果：
[0, 4, 3, 2, 1]
​
运行第二次结果：
[4, 0, 1, 2, 3]
​
运行第三次结果：
[1, 0, 3, 2, 4]

南阳道人
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java 从入坑到放弃】No 1
05-20
【Java 从入坑到放弃】No 1
uni-app入坑指南
02-24
详情点击uni-app官方文档uni-app在跨端数量、扩展能力、性能体验、周边生态、学习成本、开发成本等6大关键指标上拥有极强的竞争优势。跨端数量更多平台能力不受限性能体验更优秀周边生态丰富学习成本低开发成本低...
【入坑Java第二天】
weixin_44830111的博客
08-10 143
基础语法
入坑Java的程序媛（二）
weixin_44544682的博客
01-04 3117
全程跟b站博主@遇见狂神说 Java基础视频 一、用户交互Scanner 1.实现程序与人的交互，java提供给我们一个工具类，我们就可以获取用户的输入，可以通过Scanner类来获取用户的输入。 2.基本语法： Scanner s = new Scanner(System.in); 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前，我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。 3.next() （1）一定要读取到有效字符后
入坑Java的程序媛（一）
weixin_44544682的博客
01-04 167
Java基础知识学习 卸载JDK 1.寻找安装目录：环境变量中进行删除JAVA_HOME 2.删除path下关于java的目录 3.Java-version进行检查 安装JDK 1.百度搜索JDK8，找到下载地址 2.同意协议 3.下载电脑对应的版本 4.双击安装JDK 5.记住安装的路径 6.配置环境变量 7.测试JDK是否安装成功 第一个程序：“Hello World” 1.新建java文件 2.编写代码 3.在文件指定位置进行打开cmd命令窗口 4.编译javac java文件，会生成一个clas
Java入坑的第一天——Scanner类（读取输入）
See__word的博客
11-29 512
Scanner类 java5添加了Scanner类。 java.util.Scanner----可以通过Scanner类来获取用户的输入 java通过键盘输入数值不像C和C++那样可以通过特定函数的使用输入。 Scanner in = new Scanner(System.in);//Scanner获取用户的输入 其次呢通过Scanner类的next（）和nextLine（）方法获取...
JAVA入坑之GUI编程
qq_62377885的博客
05-01 1937
AWT是Java提供的用来建立和设置Java的图形用户界面的基本工具，它提供了一套与本地图形界面进行交互的接口12。AWT的图形函数与操作系统提供的图形函数有着一一对应的关系，也就是说，当使用AWT时，Java程序会调用操作系统的图形函数来绘制界面每类事件都有对应的事件监听器，AWT一共10类事件，11个接口。
Java入坑之语法糖
qq_62377885的博客
09-16 316
是一种常用的循环结构，它可以通过一个变量（通常是 i）来控制循环的次数和范围。是 Java 1.5 的新特性之一，它可以方便地遍历数组或集合中的元素，而不需要使用下标或迭代器。for 和 for-each 循环的效率和适用性取决于遍历对象的数据结构。一般来说，对于数组或 ArrayList 这样基于数组的数据结构，使用 for 循环更快，因为它可以直接通过下标访问元素，而不需要额外的对象创建和类型转换。
入坑Java（六）详谈类与对象
Connor0x0Lee的博客
02-09 129
类的构造方法 简单来说就是跟类名字一样的无参数方法，跟类名字一样的无参数方法就是类的构造方法，比如： public class TryFirst { TryFirst() {} } 我们之前说方法名首字母小写，这个就不用，因为这个是构造方法，要的就是跟类名一样，大小写也是啦。 如果变成： public class TryFirst { TryFirst(int a) {} } 方法有参数的...
入坑Java（三）算术运算符
Connor0x0Lee的博客
02-08 144
算术符号 优先级别6要大于7哦，也就是，先运行优先级6的运算符后才会运行7的运算符。 常用运算符： 1）*我们常用的赋值运算符“=”如 int a = 2; 2）位运算符：与&amp; 全1则1，否则为0; 或 | 全0则0，否则为1; 非 ~ 遇1则0，遇0则1; 异或 ^ 相同为0，不同为1. 在这里还有一种异或的加密方法，比如：3 ^ 5 = 6 ； 6 ^ 5 = 3。对同一个...
【入坑JAVA安全】怎么攻击RMI应用？
一个安全研究员
04-15 1801
既然你诚心诚意的问了，那我就大发慈悲的告诉你
入坑 Java开发的自学路线（Java学习路线、Java入坑指北）
08-30
入坑_Java开发的自学路线（Java学习路线、Java入坑指北）
前端入坑指南
07-07
适合完全不了解前端知识的童鞋，属于入门系列，列举了一些比较常用的东西，以及刚开始学习需要掌握的知识
Java内存模型
最新发布
weixin_44267758的博客
07-19 315
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 587
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 847
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 898
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 504
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
入坑HttpServletRequest.getParameterMap
05-17
HttpServletRequest.getParameterMap() 方法返回一个 Map,String[]> 对象，其中包含请求参数的名称作为键，相应的参数值作为值。如果参数值是一个单独的值，则该值为一个字符串数组的单元素，如果参数没有值，则该值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值