黑马程序员——Object 类，String类，StringBuffer/StringBuilder类，基本数据类型封装类

最新推荐文章于 2020-11-04 20:07:55 发布

付晓宇

最新推荐文章于 2020-11-04 20:07:55 发布

阅读量599

点赞数

分类专栏： Java学习笔记

本文链接：https://blog.csdn.net/fuxiaoyuqing/article/details/39239429

版权

Java学习笔记专栏收录该内容

21 篇文章 0 订阅

订阅专栏

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

兴趣是学习编程最好的老师

不积跬步，无以至千里

这辈子没办法做太多事情，所以每一件都要做到精彩绝伦。

<Object 类>

1.Object类位于java.lang.Object它是所有类的超类。
2.Object类中的一些基本方法：

public String toString();默认返回该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串
public boolean equals(Object obj);
1.判断"基本数据类型"的相等性，使用"=="；
2."=="也可以应用于"引用类型"，在Object中定义：判断是"引用是否相等"
3.当我们需要判断两个对象中的属性值，是否完全相同时，我们一般来重写equals()方法（见Student的equals()）

例如：

public class Test1 {

	public static void main(String[] args) {
		Student stu1 = new Student("张三",'女',18);
		Student stu2 = new Student("李四",'男',20);
		Student stu3 = new Student("王五",'女',18);
		System.out.println(stu1);
		System.out.println(stu2);
		//判断"基本数据类型"的相等性，使用"==",判断值是否相等
		int num1 = 20;
		int num2 = 20;
		System.out.println("num1 == num2 :" + (num1 == num2));//肯定是true
		//将"=="应用于引用类型:判断引用是否相等；
		System.out.println("stu1 == stu2 :" + (stu1 == stu2));//肯定是false(两个地址空间，不用考虑对象内部存储什么)
		System.out.println("stu1 == stu3 :" + (stu1 == stu3));//肯定是false(两个地址空间，不用考虑对象内部存储什么)
		Student stu4 = stu3;//将stu3的引用(地址)赋给了stu4
		System.out.println("将stu3的引用赋给了stu4......");
		System.out.println("stu3 == stu4 :" + (stu3 == stu4));//true
		//目的：判断出stu1 和 stu3是相等的；
		//使用==判断是：false
		//1使用equals()方法判断stu1 和 stu3
		//默认情况下，equals()方法同==，判断的是"引用"是否相同，
		//但是我们的目的：判断两个对象中存储的数据是否完全相同；
		//基于此目的，我们需要重写Object类的equals()
		System.out.println("stu1.equals(stu3) : " + stu1.equals(stu3));
		System.out.println("stu1.equals(stu2) : " + stu1.equals(stu2));
		
	}

<String类>

1.String 类代表字符串。字符串对象在开发中是最常见的。为了方便我们对象字符串的操作，java就把字符串用对象进行了封装。这个封装类就是String类。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
2.字符串是常量；它们的值在创建之后不能更改,可以共享
一.String类的构造器：
1).public String():默认构造器，没有任何参数
2).参数为字节数组:
   String(byte[] bytes)；
   String(byte[] bytes,int startIndex,int length)
3).参数为字符数组:
   String(char[] value);
   String(char[] value,int startIndex,int length)
  4).String(String str):

例如：

public class Test1 {

	public static void main(String[] args) {
		String str1 = new String();
		
		System.out.println("String str1 = new String():");
		System.out.println("str1 == null : " + (str1 == null));//str1是空引用么？		//false
		System.out.println("str1.length():" + str1.length());//str1中存储的字符串的长度？	//0
		System.out.println("str1.equals(\"\"):" + str1.equals(""));//str1中是空字符串么？//true
		System.out.println("---------------------");
		/*
		 * 参数为字节数组:
			String(byte[] bytes)；
			String(byte[] bytes,int startIndex,int length)
		 */
		byte[] bArray = {97,98,99,100};
		String str2 = new String(bArray);//使用byte数组构造一个String,如果byte数组都是整数，对应0-127就是ASCII码表的值
		System.out.println("str2 = " + str2);
		String str3 = new String(bArray,1,3);//用bArray来构造，从bArray的索引1开始，取2个
	//	String str3 = new String(bArray,1,4);// java.lang.StringIndexOutOfBoundsException:(运行时异常)
		System.out.println("str3 = " + str3);
		/*
		 * 参数为字符数组:
	 		String(char[] value);
			String(char[] value,int startIndex,int length)
		 */
		char[] cArray = {'[','a','b',',','c','d',']'};
		
		String str4 = new String(cArray);
		System.out.println("str4 = " + str4);
		
		String str5 = new String(cArray,1,5);
		System.out.println("str5 = " + str5);
		/*
		 * 用一个字符串构造一个字符串：
		 * String(String str):
		 */
		String str6 = new String("abc");
		System.out.println("str6 = " + str6);
		
	}

}

3.String类的常用方法
判断
   boolean equals(Object);       判断传入的字符串是否与调用的字符串字符序列是否相同,相同就返回true否则false
   boolean equalsIgnoreCase(string); 判断传入的字符串是否与调用的字符串字符序列是否相同,不区分大小写,相同就返回true否则false
   boolean contains(string);     判断传入的字符串是否被调用的字符串包含
   boolean startsWith(string);   判断调用的字符串是否以传入的字符串开头
   boolean endsWith(string);     判断调用的字符串是否以传入的字符串结尾
   boolean isEmpty();            判断字符串是否为空

获取
   int length();                 获取字符串的长度
   char charAt(index);           通过索引获取对应的字符
   int indexOf(int ch);          通过传入int数或者是字符找对应索引
   int idnexOf(int ch,fromIndex); 在指定fromIndex的位置查找传入的字符
   int indexOf(string str);      通过传入字符串查找字符串所对应的索引
   int idnexOf(string str,fromIndex); 通过指定fromIndex的位置查找传入的字符串
   int lastIndexOf(ch);          通过传入的字符从后向前找字符的索引值,把从后向前第一次找到的索引值返回
   int lastIndexOf(ch,fromIndex): 通过指定fromIndex的位置,从后向前查找字符,把从后向前第一次找到的索引值返回
   int lastIndexOf(string);      通过传入的字符串,从后向前查找,将第一次找到字符串中第一个字符的索引返回
   int lastIndexOf(string,fromIndex): 通过指定fromIndex的位置,从后向前查找对应字符串,将第一次找到字符串中第一个字符的索引返回
   String substring(start);      通过传入的索引值开始向后截取,截取的是索引到length
   String substring(start,end); 通过传入的两个索引值截取,有开始有结尾,包含头不包含尾
转换

   byte[] getBytes():使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
   char[] toCharArray()：将此字符串转换为一个新的字符数组。
   static String copyValueOf(char[] chs):返回指定数组中表示该字符序列的 String
   static String valueOf(char[] chs):返回 char 数组参数的字符串表示形式。字符数组的内容已被复制，后续修改不会影响新创建的字符串。
   static String valueOf(int i)基本类型
   String toLowerCase():使用默认语言环境的规则将此 String 中的所有字符都转换为小写
   String toUpperCase():使用默认语言环境的规则将此 String 中的所有字符都转换为大写
   String concat(String str)：将指定字符串连接到此字符串的结尾。

替换
   String replace(oldChar,newChar); //将newChar替换OldChar,如果OldChar不存在,原字符串直接赋值给替换后字符串
   String replace(string,string);

切割
  String[] split(regex);     //通过regex切割字符串,切割后会产生一个字符串数组
  String s = "金三胖郭美美李天一";
  String[] arr = s.split(" ");

去除字符串两空格
  String trim();

比较
  String str = "ab";
  String str1 = "bc";
  int num = str.compareTo(str1);   //如果str比str1大的话,返回的正数

例如：

public class Test {

	public static void main(String[] args) {
		String str = "abc";
		//1.byte[] getBytes():使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
		byte[] byteArray = str.getBytes();
		for(int i : byteArray){
			System.out.println(i);
		}
		System.out.println("--------------------");
		//2.char[] toCharArray()：将此字符串转换为一个新的字符数组。 
		char[] charArray = str.toCharArray();
		for(char c : charArray){
			System.out.println(c);
		}
		System.out.println("--------------------");
		//3.static String copyValueOf(char[] chs):返回指定数组中表示该字符序列的 String
		char[] chArray ={'中','a','国','b'};
		String temp = String.copyValueOf(chArray);
		System.out.println(temp);
		System.out.println("--------------------");
		//4.static String valueOf(char[] chs):返回 char 数组参数的字符串表示形式。字符数组的内容已被复制，后续修改不会影响新创建的字符串。 
		temp = String.valueOf(chArray);
		System.out.println(temp);
		System.out.println("--------------------");
		//5.static String valueOf(int i)：以及其他重载的方法，将基本类型转换为字符串
		temp = String.valueOf(20);
		System.out.println(temp);
		System.out.println(20);
		System.out.println("--------------------");
		//6.String toLowerCase():使用默认语言环境的规则将此 String 中的所有字符都转换为小写
		//7.String toUpperCase():使用默认语言环境的规则将此 String 中的所有字符都转换为大写
		String str2 = "HelloWorld";
		System.out.println("str2.toLowerCase()(转换为小写) : " + str2.toLowerCase());
		System.out.println("str2.toUpperCase()(转换为大写) : " + str2.toUpperCase());
		//8. String concat(String str)：将指定字符串连接到此字符串的结尾。
		System.out.println("str2.concat(\"!!!!\") : " + str2.concat("!!!!"));
		System.out.println("str2 = " + str2);
	}

}

<StringBuffer/StringBuilder类>

1.StringBuffer类和StringBuilder类的功能完全一致，只是StringBuilder是线程不安全的,所以效率比较高,1.5版本出现，StringBuffer是线程安全的,效率相对较低,1.0版本出现的

2.构造方法：

public StringBuffer()
构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
public StringBuffer(int capacity):
  使用一个初始容量来构造StringBuffer
public StringBuffer(String str):
使用一个字符串来构造StringBuffer

成员方法：
public int capacity()：返回StringBuffer的当前容量
public int length()：返回包含的字符数;
3.StringBuffer的常用方法
添加
  StringBuffer append(int x);     //在缓冲区的末尾追加
  StringBuffer insert(int index,String str); //在指定索引位置添加

删除
  StringBuffer delete(int start, int end); //包含头索引,不包含尾部索引
  StringBuffer delete(0,sb.length);   //清空缓冲区
   sb = new StringBuffer();
sb.append("aaaaa");
sb = new StringBuffer();
  StringBuffer deleteCharAt(int index);  //根据指定的索引删除索引对应的元素

修改
  StringBuffer replace(int start,int end,string);//用String替换,包含头不包含尾
  void setCharAt(int index ,char);   //修改,把指定索引位置的值改成传入的char值
  StringBuffer reverse();      //将缓冲区的元素反转
  void setLength(int len);     //根据传入的len值截取缓冲区的长度
     toString()         //转换成String

查找
  int indexOf(str);       //查找str在缓冲区第一次出现的位置
  int lastIndexOf(str);      //从后向前查找查找str在缓冲区第一次出现的位置

public class Test {
	public static void main(String[] args) {
		StringBuffer buf1 = new StringBuffer();
		buf1.append("hello");
		System.out.println("容量：" + buf1.capacity());
		System.out.println("长度：" + buf1.length());
		buf1.append(true);
		System.out.println("容量：" + buf1.capacity());
		System.out.println("长度：" + buf1.length());
		buf1.append(3.14159);
		System.out.println("容量：" + buf1.capacity());
		System.out.println("长度：" + buf1.length());
		buf1.append("121212121212121212122222");
		System.out.println("--容量：" + buf1.capacity());//如果之前容量不够，将增加原长度的2倍 + 2
		System.out.println("--长度：" + buf1.length());
		buf1.append("1");
		System.out.println("容量：" + buf1.capacity());//如果之前容量不够，将增加原长度的2倍 + 2
		System.out.println("长度：" + buf1.length());
		
		System.out.println("----insert()----");
		StringBuffer buf2 = new StringBuffer("Hello");
		System.out.println(buf2.insert(5, "xxx"));//offset后移，将字符串插入:Hxxxello
	//	System.out.println(buf2.indexOf(6,"xxx"));//java.lang.StringIndexOutOfBoundsException（运行时）offset值一定<=字符长度
		System.out.println("----delete()----");
		StringBuffer buf3 = new StringBuffer("HelloWorld");
		System.out.println(buf3.delete(1, 2));//World
		
		System.out.println("----deleteCharAt()----");
		StringBuffer buf4 = new StringBuffer("HelloWorld");
		System.out.println(buf4.deleteCharAt(9));//
		
		System.out.println("----replace()----");
		StringBuffer buf5 = new StringBuffer("HelloWorld");
		System.out.println(buf5.replace(2, 5, "XXXX"));
		
		System.out.println("----substring()----");
		StringBuffer buf6 = new StringBuffer("HelloWorld");
		System.out.println(buf6.substring(10));
		System.out.println(buf6);
		
		System.out.println("--" + buf6.substring(7,8));
		
		System.out.println("----reverse()----");
		StringBuffer buf7 = new StringBuffer("你好中国");
		System.out.println(buf7.reverse());
		
	}

}

<基本数据类型封装类>

1.基本数据类型——封装类：

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

2.封装类

集合的泛型中只能写包装类型，基本数据类型不是对象不能直接装入。

在JDK5之前, 如果想把基本数据类型装入集合, 必须人工的进行包装(转为包装类对象)，JDK5之后, 基本数据类型和包装类之间可以自动的互相转换了。

3.包装类常用的方法
  static int parseInt(String s) //将数字字符串转换成数字,如果是非数字字符串会转换失败,抛异常
  Integer.toBinaryString()  //将一个十进制数字,转换成二进制的字符串
  Integer.toOctalString()   //将一个十进制数字,转换成八进制的字符串
  Integer.toHexString()   //将一个十进制数字,转换成十六进制的字符串
  static long parseLong(String s)
  static double parseDouble(String s)
  static char forDigit(int digit, int radix)// radix代表的是进制例如二进制就传2,八进制就传8,digit代表后面进制里面的元素,而且不能超出后面进制的范围
  String s = "123";
  int x = Integer.parseInt(s);
  String s = "abc";
  char ch = Character.parseChar(s);

<正则表达式>

1.正则表达式是一种字符串的约束格式.
2.匹配
  String里的matches() 验证一个字符串是否匹配指定的正则表达式"18612345678".matches("1[34578]\\d{9}");
3.分割
  String里的split() 用指定正则表达式能匹配的字符作为分隔符, 分割字符串
4.替换
  String里的replaceAll("","") 把字符串中能匹配正则表达式的部分替换为另一个字符串
5.查找
  Pattern.compile() 创建正则表达式对象
  Pattern.matcher() 用正则表达式匹配一个字符串, 得到匹配器
  Matcher.find() 查找字符串中是否包含能匹配正则表达式的部分
  Matcher.group() 获取匹配的部分

例如：

public class Test {

	public static void main(String[] args) {
		String str = "hid";
		/*********正则表达式-字符类************/
		//字符串中是否以h开头，以d结尾，而且中间只有一个字符，而且是元音字母a、e、i、o、u？
		String regex = "h[aeiou]d";
		System.out.println(str.matches(regex));
		//字符串中是否以h开头，以d结尾，而且中间只有一个小写英文字母？
		regex = "h[a-z]d";
		System.out.println(str.matches(regex));
		//字符串是否以大写英文字母开头，后跟id?
		String s = "A";
		regex = "[A-Z]id";//"[" + s + "-Z]id"
		System.out.println(str.matches(regex));
		//字符串首字母是否非数字？
		regex = "[^0-9]id";
		System.out.println(str.matches(regex));
		/********正则表达式-逻辑运算符**********/
		//判断小写辅音字母：
		String s1 = "ba";
		regex = "[a-z&&[^aeiou]]a";
		//判断首字母为h 或 H ，后跟一个元音字母，并以 d 结尾
		regex = "[hH][aeiou]d";
		
		/*******正则表达式-预定义字符类********/
		regex = "[0-9][0-9][0-9]";//使用字符类的方式
		regex = "\\d\\d\\d";//使用预定义字符类的方式:\\d 相当于[0-9]
		s1 = "23";
		System.out.println(s1.matches(regex));
		
		//2.判断字符串是否以h开头，中间是任何字符，并以d结尾："h.d"
		regex = "h[.]d";//只匹配：h.d
		regex = "h.d";//匹配：h[任何字符]d
		s1 = "h中d";
		System.out.println(s1.matches(regex));
		//3.判断字符串是否是”had.”:
		regex = "had\\.";//可以
		regex = "had[.]";//也可以
		s1 = "hadd";
		System.out.println(s1.matches(regex));
		//4.判断手机号码(1开头，第二位是：3,4,5,7,8，后跟9位数字)：
		regex = "1[34578][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]";
		regex = "1[34578]\\d\\d\\d\\d\\d\\d\\d\\d\\d";
		
		s1 = "19513865765";
		System.out.println(s1.matches(regex));
		
		/******使用限定符***********/
		regex = "1[34578]\\d{9}";//相当于：1[34578][0-9]{9}
		
		//1.判断1位或多位数字
		regex = "\\d+";
		s1 = "1";
		System.out.println(s1.matches(regex));
		//2.判断小数(小数点最多1次)：
		regex = "\\d+\\.?\\d+";
		s1 = "3.1415";
		System.out.println(s1.matches(regex));
		//3.判断数字(可出现或不出现小数部分)：
		regex = "\\d+(\\.?\\d+)?";
		s1 = "22.";
		System.out.println(s1.matches(regex));
		//4.满足："22."的格式
		regex = "\\d+(\\.?\\d*)?";
		s1 = "22.";
		System.out.println(s1.matches(regex));
		//5.满足：+20，-3，22.格式：
		regex = "[+-]?\\d+(\\.?\\d*)?";
		s1 = "+-22.3";
		System.out.println(s1.matches(regex));
	}

}

付晓宇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——Object 类，String类，StringBuffer/StringBuilder类，基本数据类型封装类

------http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
复制链接

扫一扫