String类-Integer类-Character类及其构造方法

最新推荐文章于 2023-07-19 19:32:15 发布

程序小问题

最新推荐文章于 2023-07-19 19:32:15 发布

阅读量441

点赞数 1

分类专栏：类文章标签： java 类

本文链接：https://blog.csdn.net/weixin_44435366/article/details/107365461

版权

类专栏收录该内容

3 篇文章 0 订阅

订阅专栏

封装类

1. 在java中8个基本数据类型都有与之对应的封装类 因为基本数据类型不能调用方法和属性 通过它的封装类可以访问属性和方法。 2. byte Byte 
short Short 
int Integer 
long Long 
float Float 
double Double 
boolean Boolean 
char Character

String <–> 基本数据类型

<1> String 转基本数据类型

除了char，其他的数据类型都满足 
基本数据类型 自定义变量名 = 封装类.parseXXXX("值"); 例如：Byte 类 static byte parseByte(String s) 将字符串参数解析为带符号的十进制 byte 
Long 类 static long parseLong(String s) 将字符串参数解析为带符号的十进制 long 
Short 类 static short parseShort(String s) 将字符串参数解析为带符号的十进制 short 
Integer 类 static int parseInt(String s) 将字符串参数解析为带符号的十进制整数。 
Double 类 static double parseDouble(String s) 返回一个新 double初始化为指定的 
Float 类 static float parseFloat(String s) 返回一个新 float初始化为指定的代表 
Boolean 类 static boolean parseBoolean(String s) 将字符串参数解析为布尔值。

public class Demo {
	public static void main(String[] args) {
		String s = "20";
		int i = Integer.parseInt(s);
		System.out.println(i);
		
		String s1 = "50";
		long i1 = Long.parseLong(s1);
		System.out.println(i1);
		
		String s2 = "60";
		short i3 = Short.parseShort(s2);
		System.out.println(i3);
		
		String s3 = "3.1415";
		float i4 = Float.parseFloat(s3);
		System.out.println(i4);
		
	}

	
}

基本数据类型转 String

<1> 直接与"“连接 34+”" 就会变成字符串

<2> 调用String类中有重载 valueOf方法

static String valueOf(boolean b) 返回 boolean参数的字符串 boolean形式。

static String valueOf(char c) 返回 char参数的字符串 char形式。

static String valueOf(char[] data) 返回 char数组参数的字符串 char形式。

static String valueOf(char[] data, int offset, int count) 返回char数组参数的特定子阵列的字符串

static String valueOf(double d) 返回 double参数的字符串 double形式。

static String valueOf(float f) 返回 float参数的字符串 float形式。

static String valueOf(int i) 返回 int参数的字符串 int形式。

static String valueOf(long l) 返回 long参数的字符串 long形式。

static String valueOf(Object obj) 返回 Object参数的字符串 Object形式。

3> 调用对应包装类方法，static String toString(xxx 变量名)

Integer 类 static String toString(int i)

Byte 类 static String toString(byte b)

Short 类 static String toString(short s)

Long 类 static String toString(long l)

Float 类 static String toString(float f)

Double 类 static String toString(double d)

Character 类 static String toString(char c)

Boolean 类 static String toString(boolean b)

Integer类

public final class Integer//被final修饰的类和不可以被继承，方法不可以被重写
extends Number
implements Comparable<Integer>//实现Comparable接口
Integer类包装一个对象中的原始类型int的值。 类型为Integer的对象包含一个单一字段，其类型为int 。 
此外，该类还提供了一些将int转换为String和String转换为int ，以及在处理int时有用的其他常量和方法。

public class IntegerDemo {
	public static void main(String[] args) {
		//Integer 是int 的封装类
		
		//学习1：如何创建Integer对象
		//类名   对象名   =  new 类名(String  (int val));
		//
		Integer i = new Integer(10);
		//参数：必须能够转换成int类型的字符串，都在会抛出NumbarFormatExcetption数字格式化异常
		Integer n = new Integer("100");
		System.out.println(i);
		System.out.println(n);
		//学习2：学习5个常量值，常量的值不能修改
		int v1 = Integer.BYTES;
		System.out.printf("int类型%d个字节%n",v1);
		//-2^31-2^31-1  最大值----最小值
		System.out.printf("int类型的取值范围【%d--%d】%n",Integer.MIN_VALUE,Integer.MAX_VALUE);
	    //Integer字节数
		System.out.printf("int类型%d个字节%n",Integer.SIZE);
	
		//Integer的类型为int
		Class<Integer> c = Integer.TYPE;
		System.out.println(c);
	}
}

Integer方法（static和非静态方法）

static方法

public class Integerstatic {

	public static void main(String[] args) {

		// 学习3：调用Integer类中的静态方法

		// 调用静态方法的方法
		// 返回值类型 变量名 = 类名.方法名（实参）；

		// static int bitCount(int i) 返回指定的int值的二进制补码二进制表示中的 int数。
		int num = Integer.bitCount(7);
		System.out.println("7转换成二进制数中1的个数为：" + num);

		// static String toBinaryString(int i)十进制转--->二进制
		String s1 = Integer.toBinaryString(8);
		System.out.println("8的二进制数：" + s1);

		// static String toHexString(int i) 十进制转--->十六进制
		String s2 = Integer.toHexString(15);
		System.out.println("15的十六进制数为：" + s2);

		// static String toOctalString(int i) 十进制转--->八进制
		String s3 = Integer.toOctalString(13);
		System.out.println("13的八进制数为：" + s3);

		// 二进制 八进制 十六进制转换成十进制数
		int k1 = Integer.valueOf("1100100", 2);// 二进制数转换成十进制
		int k2 = Integer.valueOf("64", 16);// 十六进制转换成十进制
		int k3 = Integer.valueOf("144", 8);// 八进制转换成十进制
		System.out.println(k1 + "," + k2 + "," + k3);

		// static int max(int a ,int b)返回最大值
		int i1 = Integer.max(3, 4);
		System.out.println("最大值为：" + i1);
		// static int min(int a ,int b)返回最小值
		int i2 = Integer.min(3, 4);
		System.out.println("最小值为：" + i1);

		
		//String---->int
		//static int parseInt(String s)
		int age = Integer.parseInt("20");
		System.out.println("年龄为："+age);
		
	}
}

非静态方法

public class IntegerOuStatic {
	public static void main(String[] args) {
		
	
	//学习4：Integer中的非静态方法
	
	Integer x = new Integer("10");
	Integer y = new Integer("10");
	System.out.println(x.toString());
	int v1 = x.intValue();//将Integer对象转换成int类型
	int v2 = y.intValue();
	System.out.println(v1==v2);//true
	System.out.println(x==y);
	boolean flag = x.equals(y);//true,因为重写了Objct的equals
	System.out.println(flag);
	
	
	}
}

自动拆箱和装箱

public class IntegerDem02 {
	public static void main(String[] args) {
		// 查看valueOf源码，发现值再-128-127，直接从Integer[]中取一个Integer对象
		// 自动装箱：int自动转换成Integer
		Integer x = 100;
		Integer i = Integer.valueOf(x);// 底层代码自动装箱，可以不用写
		System.out.println(i);
		x = x + 5;// 先将x转换成int，再算数运算，再把结果装箱
		int x1 = Integer.valueOf(x);// 拆箱
		System.out.println(x1);
		System.out.println(x);

		int a = 10;
		int b = 10;
		System.out.println(a == b);// 值比较为true

		Integer n1 = 10;
		Integer n2 = 10;
		System.out.println(n1 == n2);// 在-128-127内自动装箱为同一个Integer对象，比较地址，为true

		Integer n3 = 200;
		Integer n4 = 200;
		System.out.println(n1 == n2);// 超过范围大于128，自动装箱为new Integer新对象，比较地址，地址不同为false

	}

}

Character类（Char）

```
public final class Character//不可被继承和重写
extends Object
implements Serializable, Comparable<Character>//接口
```
Character类包装一个对象中的基本类型char的值。

类型为Character的对象包含一个单一字段，其类型为char 。

此外，该类还提供了几种方法来确定字符的类别（小写字母，数字等），并将字符从大写转换为小写，反之亦然。

package com.javase14;

import java.util.Arrays;
import java.util.Scanner;

public class CharFeng {
	
	public static void main(String[] args) {
		
		//:输入一行字符串，分别统计英文字母，空格，数字和其他字符的个数
		//创建计数器
		Scanner sc = new Scanner(System.in);
		//next遇到空格就会停止扫描，nextLine回车停止扫描
		System.out.println("请输入一行字符串：");
		String str = sc.nextLine();
		//将字符串转换成字符数组
		char[] arr = str.toCharArray();
		System.out.println(Arrays.toString(arr));
		int sum = 0,sum1=0,sum2=0,sum3=0;
		for (char x : arr) {
			if(Character.isDigit(x)) {//判断是否为数字
				sum++;
			}else if(Character.isLetter(x)) {//判断是否为字母
				sum1++;
			}else if(Character.isSpaceChar(x)){//判断是否为空格
				sum2++;
			}else {
				sum3++;
			}
			
		}
		System.out.println("数字"+sum);
		System.out.println("字母"+sum1);
		System.out.println("空格"+sum2);
		System.out.println("其他"+sum3);
	}

}

String类

```
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
```
String类代表字符串。

Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。

字符串不变(底层代码的final char[] value存储的值不可改变); 它们的值在创建后不能被更改。字符串缓冲区支持可变字符串。因为String对象是不可变的，它们可以被共享。例如：

String str = “abc”;

相当于：

char data[] = {‘a’, ‘b’, ‘c’};

String str = new String(data);
以下是一些如何使用字符串的示例：

System.out.println(“abc”);

String cde = “cde”;

System.out.println(“abc” + cde);

String c = “abc”.substring(2,3);

String d = cde.substring(1, 2);

public class StringDemo1 {
	
	public static void main(String[] args) {
		//"abc"字符串对象 "haha"字符串对象
		//s1引用
		String s1 = "abc";//"abc"依旧存在
		s1 = "haha";
		System.out.println(s1);
	}
}

String 类的常用构造函数

String() 初始化新创建的 String对象，使其表示空字符序列。 String(byte[] bytes) 通过字节数组来创建字符串 String(byte[] bytes, String charsetName) 指定字符编码集 String(char[] value) 通过字符数组来创建字符串 String(String original) 通过一个字符串来创建一个新的字符串

public class StringDemo2 {
	
	public static void main(String[] args) {
	
		//第一种：直接赋值
		String s1 = "孙悟空";
		
		//第二种：new + 构造方法
		String s2 = new String();//""
		System.out.println(s2.length());
		
		String s3 = new String("猪八戒");
		System.out.println(s3);
		
		byte[] arr1 = {97,98,99,100};
		String s4 = new String(arr1);
		System.out.println(s4);
		
		
		char[] arr2 = {'a','b','c'};
		String s5 = new String(arr2);
		System.out.println(s5);
		
		//第三种：intern
		//去字符串常量池中搜索"孙悟空"一样的字符串
		//有则直接s6指向常量池的孙悟空，没有就在常量池中创建一个
		//s6指向刚刚所创建的对象
		String s6 = s1.intern();
		System.out.println(s6);
		System.out.println(s1==s6);
		System.out.println(s1==s3);
		
		
	}
}

String类中常用的方法

获取字符个数 length

public class StringDemo {
	public static void main(String[] args) {
		String s1 = "如来佛祖a";
		int len = s1.length();
		System.out.println(len);//返回的字符串的个数为5
	}

}

获取部分字符串 substring

String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。 
String substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串

public class StringDemo {
	public static void main(String[] args) {
		String s = "亚瑟abc王昭君";
		          //0 1234 567
		String s1 = s.substring(2);//从2开始截取到6
		String s2 = s.substring(2,4);//从2截取到3
		System.out.println(s);
		System.out.println(s1);
		System.out.println(s2);
	}

}

字符串是否以指定字符串开头或者结尾 startsWith，endsWith

boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头。 
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。

package com.javase14;

public class StringDemo {
	public static void main(String[] args) {
		String s = "D:\\rd\\s2005\\javase14\\StringDem0.java";

		boolean f = s.startsWith("D:");// 判断是否存在D盘
		System.out.println(f);
		boolean f1 = s.endsWith(".java");// 判断是否存在此文件
		System.out.println(f1);
	}
}

字符串中是否包含另一个字符串 contains,indexOf

boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true。 
int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。 
int indexOf(String str, int fromIndex) 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。 
int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。 
int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。

public class StringDemo {
	public static void main(String[] args) {
		String s = "This is a pig no has is cat";
		boolean flag = s.contains("cat");
		System.out.println("s中是否存在包含cat字符串："+flag);
		int index = s.indexOf("cat");
		System.out.println("从前往后搜索，cat在s中第一次出现的位置为："+index);
		int index1 = s.lastIndexOf("cat");
		System.out.println("从后往前搜索，cat在s中第一次出现的位置为："+index1);

		
		int index2 = s.indexOf("cat",4);
		System.out.println("从指定位置搜索，cat在s中第一次出现的位置为："+index2);
	}
}

将字符串转成为byte[ ] 或者 char[ ] getBytes,toCharArray

char[] toCharArray() 将此字符串转换为新的字符数组。 
byte[] getBytes() 将字符串转换成字节数组

mport java.util.Arrays;

public class StringDemo {
	public static void main(String[] args) {
		
		String s = "我不是很会读abcd";
		char[] arr1 = s.toCharArray();
		byte[] arr2 = s.getBytes();
		System.out.println(Arrays.toString(arr1));
		System.out.println(Arrays.toString(arr2));
	
	}
}

判断两个字符串是否相等 equals，equalsIgnoreCase html

String重写Object类的equals和hashCode方法，有了自己比较规则

boolean equals(Object anObject) 比较两个字符串的内容是否相等 
boolean equalsIgnoreCase(String anotherString) 不考虑大小写比较内容是否相等

public class StringDemo {
	public static void main(String[] args) {
		
		String s = "Vua4";
		String s1 = "VUA4";
		boolean v1 = s.equals(s1);
		boolean v2 = s.equalsIgnoreCase(s1);
		System.out.println(v1);
		System.out.println(v2);
	
	}
}

toString

String类重写 Object类的toString，所以输出格式不是

包名.类名@内存地址的16进制数格式

public class StringDemo{
	
	public String toString() {
		return "调用重写的toString";
	}
	public static void main(String[] args) {
		
		StringDemo d = new StringDemo();
		String s = d.toString();
		System.out.println(s);
	}
}

判断是否为空字符串 isEmpty

boolean isEmpty() 返回 true如果，且仅当 length()为 0 。

public class StringDemo{
	
	public static void main(String[] args) {
		String s ="";
		boolean f = s.isEmpty();
		System.out.println(f);
		
	}
}

获取指定索引位置上的字符 charAt

char charAt(int index) 返回 char指定索引处的值。 
注意： 防止字符串索引越界异常，记得我们以前学习过数组索引越界 0 - 字符串字符长度-1
    
    public class StringDemo{
	
	public static void main(String[] args) {
		String s ="abcdef";
		char f = s.charAt(3);
		//注意：防止字符串索引越界异常[0-length()-1] 
		// StringIndexOutOfBoundsException 
		// 字符串 索引 越界 异常
		System.out.println(f);
		
	}
}

大小写转换 toLowerCase , to UpperCase

String toLowerCase() 转小写 
String toUpperCase() 转大写

public class StringDemo{
	
	public static void main(String[] args) {
		
		String s = "abcdEFGH";
		String s1 = s.toLowerCase();
		String s2 = s.toUpperCase();
		System.out.println(s1);
		System.out.println(s2);
		
	}
}

字符串替换 replace, replaceAll

//把所有满足条件旧字符或者旧字符串，使用新的替换 
String replace(char oldChar, char newChar) 替换一个字符 String replace(CharSequence target, CharSequence replacement) 替换一个字符串 
//以下两个方法，支持正则表达式regex，还没有学习 
String replaceAll(String regex, String replacement) 替换所有的满足条件的字符串 
String replaceFirst(String regex, String replacement) 替换满足条件的第1个字符串

public class StringDemo{
	
	public static void main(String[] args) {
		
		String str = "this is my name.";
		String s1 = str.replace('i', '*');
		System.out.println(str);
		System.out.println(s1);
		
		String s2 = str.replace("is", "$");
		System.out.println(s2);
		
		String s3 = str.replaceAll("[0-9]", "编号");
		System.out.println(s3);
		
		String s4 = str.replaceFirst("[0-9]", "编号");
		System.out.println(s4);
		
	}
}

字符串连接 concat , join

String concat(String str) 将指定的字符串连接到该字符串的末尾。

static String join(CharSequence delimiter, CharSequence… elements)返回一个新的字符串

public class StringDemo{
	
	public static void main(String[] args) {
	
		String s = "孙悟空";
		String s1 = s.concat("猪八戒");
		System.out.println(s1);
		
		String s2 = String.join("*", "10","20","30","40");
		System.out.println(s2);
		
	}
}

去掉字符串中前后空格trim

String trim() 去掉字符串的前后空格，注意：中间的空格不能删除

public class StringDemo{
	
	public static void main(String[] args) {
	
		String s = "    i love you";
		System.out.println(s);
		String s1 = s.trim();
		System.out.println(s1);
		
	}
}

比较两个字符串顺序

由"a".compareTo("b")得到的数值 
int result = "a".compareTo("b"); 
// 0 代表相等 <0 代表比字符串参数小 >0 代表比字符串参数大 
// 按照字典顺序比较 
System.out.println(result); // -1

通过三种方式创建了字符串对象

String s1 = "abc"; //常量池中 
String s2 = "abc"; //常量池中 
String s3 = new String("abc"); //在堆中新创建一个地址存储"abc" 
String s4 = new String("abc"); //在堆中新创建一个地址存储"abc" 
String s5 = s3.intern(); //先去常量池中搜索"abc"，有直接返回，没有新建 // 比较地址 
System.out.println(s1 == s2); // ? true
System.out.println(s3 == s4); // ? false
System.out.println(s2 == s3); // ? false
System.out.println(s5 == s3); // ? false
System.out.println(s1 == s5); // ？true