Java-Object类、String类、StringBuffer、排序、基本类型包装类

Object类

HashCode() 返回一个int 型的数，进内存申请的位置

getClass() 返回此对象的运行时类，获取该对象的字节码文件，返回的是class

equals() 比较两个对象是否相等，Object中的equals方法是比较对象的地址值的，没有什么意义，我们需要重写它，因为在开发中我们通常比较的是对象中的属性值，我们认为相同属性是同一个对象，这样我们就需要重写equals()。

 

== 和 equals() 的区别

共同点：都可以做比较，返回值是boolean型

区别：

== 是比较运算符，既可以基本数据类型，也可以比较引用型数据类型，基本数据类型比较的是值，引用数据类型比较的是地址值。

equals() 只能比较的是引用型数据类型，在没有重写之前比较的是地址值，底层依赖的是==号，但是比较地址值是没有意义的，我们需要重写equals()方法比较对象的属性值。

 

Scanner java.util包下

• hasNextIntXxx（）：判断是否还有下一个输入项，其中Xxx可以是Int、Double等，如果需要判断是否包含下一个字符串，则可以省略Xxx
• nextXxx（）：获取下一个输入项。默认情况下，Scanner使用空格、回车等作为分隔符。
• nextLine（）：获取String类型的值

 

String类

字符串是常量，一旦被赋值，就不能被改变

String类重写了toString方法，返回值是该对象本身

String类的构造方法

* public String():空构造

* public String(byte[] bytes):把字节数组转成字符串

* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串

* public String(char[] value):把字符数组转成字符串

* public String(char[] value,int index,int count):把字符数组的一部分转成字符串

* public String(String original):把字符串常量值转成字符串

public static void main(String[] args) { String s1 = new String(); System.out.println(); byte[] arr1 = {97,98,99}; String s2 = new String(arr1); //解码，将计算机读得懂的转换成我们读得懂的 System.out.println(s2); byte[] arr2 = {97,98,99,100,101,102}; String s3 = new String(arr2,2,3); //将arr2字节数组从2索引开始转换3个 System.out.println(s3); char[]arr3 = {'a','b','c','d','e'}; String s4 = new String(arr3); //将字符数组转换成字符串 System.out.println(s4); String s5 = new String(arr3); //将arr3字符数组，从1索引开始转换3个 System.out.println(s5); String s6 = new String("zhangshan"); System.out.println(s6); }

 

String str = new String("abc"); //创建了两个对象，一个在常量池，一个在堆内存

 

String类的判断功能

* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

* boolean contains(String str):判断字符串中是否包含传入的字符串

* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾

* boolean isEmpty():判断字符串是否为空。

""和null的区别：

• "" 是字符串常量，同时也是一个String对象，既然是对象当然可以调用String类中的方法
• null 是空常量，不能调用任何的方法，否则会出现空指针异常，null可以给任意的引用数据类型赋值。

 

String类的获取功能

* int length():获取字符串的长度。数组中的length是属性，这里的是方法。

* char charAt(int index):获取指定索引位置的字符

* int indexOf(int ch):

1>返回指定字符在此字符串中第一次出现处的索引。

2>参数接收的是int类型的，传递char类型的会自动提升。

3>如果不存在，则会返回-1。

* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。

* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。

 

* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

* lastIndexOf：从后向前找第一次出现的位置

* String substring(int start):从指定位置开始截取字符串,默认到末尾。

* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包含头不含尾，即左闭右开。subString会产生一个新的字符串，需要一个新的字符记录。

 

String的转换功能：

* byte[] getBytes():把字符串转换为字节数组。

* char[] toCharArray():把字符串转换为字符数组。

* static String valueOf(char[] chs):把字符数组转成字符串。

* static String valueOf(int i):把int类型的数据转成字符串。

* 注意：String类的valueOf方法可以把任意类型的数据转成字符串

 

* String toLowerCase():把字符串转成小写。(了解)

* String toUpperCase():把字符串转成大写。

* String concat(String str):把字符串拼接。调用的和传入的都是String类型，而用+连接更强大，可与任意类型进行连接。

* Character.isSpaceChar(ch[i]):判断一个字符数组的字符是否是空格

 

String类的其他功能

*A:String的替换功能及案例演示

* String replace(char old,char new)

* String replace(String old,String new)

 

* B:String的去除字符串两空格及案例演示

* String trim()

 

* C:String的按字典顺序比较两个字符串及案例演示

* int compareTo(String str)(暂时不用掌握)

* int compareToIgnoreCase(String str)(了解)

 

StringBuffer

public final class StringBuffer

线程安全的可变字符序列，同步的。类似于String的字符缓冲区，但不能修改，可以通过某些方法改变该序列的长度和内容。

String与StringBuffer的区别：

String是一个不可变的序列，StringBuffer是一个可变的字符序列

 

StringBuffer构造方法

字符串缓冲区的初始容量为16个字符，只要字符串缓冲区所包含的字符序列长度没有超出此容量，就无需分配新的内部缓冲区数组，如果超出，则此容量自动增大。

 

capacity（）：StringBuffer容器的初始容量，理论值

 

添加功能：

1> append()

StringBuffer是字符串缓冲区，当new的时候是在堆内存里创建了一个对象，底层是一个长度为16的字符数组，当调用添加方法时，不会再重新创建对象，在不断的向原缓冲区添加字符。可以把任意类型的数据添加到字符串缓冲区里面，并返回字符串缓冲区本身。

2> insert(int offset,String str)

在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身。

指定位置添加元素，如果没有指定位置的索引，就会报索引越界异常。

 

删除功能：

1> deleteCharAt(int index)

删除指定位置的字符，并返回字符串缓冲区本身。

当缓冲区中这个索引上没有元素的时候，就会报StringIndexOutOfBoundsException。

2> delete(int start,int end) 左闭右开 [start，end）

删除从指定位置开始到指定位置结束的内容，并返回字符串本身。

sb.delete(0, sb.length); //清空缓冲区

public static void main(String[] args) { StringBuffer sb = new StringBuffer(); // sb.deleteCharAt(2); sb.append("zhangshan"); sb.deleteCharAt(4); System.out.println(sb); sb.delete(0, 3); System.out.println(sb); }

 

 

StringBuffer的替换和反转功能

1> replace(int start,int end,String str) 左闭右开

从start开始到end结束，用str替换。

2> reverse()

字符串反转。

sb.reverse(); //逆序输出缓冲区的内容

 

StringBuffer的截取功能及注意事项

1> subString(int start)

从指定位置截取到末尾。

2> subString(int start,int end) 左闭右开

截取从指定位置开始到结束位置，包括开头不含结尾。

注意：返回值类型不再是StringBuffer本身，而是截取的内容，所以该方法的返回值类型是String。

 

StringBuffer和String的相互转换

1> String----> StringBuffer

• 通过构造方法
• 通过append()方法

//通过构造方法将字符串转换为StringBuffer对象 StringBuffer sb1 = new StringBuffer("zhangshan"); System.out.println(sb1); //通过append（）方法将字符串转换为StringBuffer对象 StringBuffer sb2 = new StringBuffer(); sb2.append("zhangshan");

 

2> StringBuffer----> String

• 通过构造方法
• 通过toString()方法
• 通过subString(0, length)方法

StringBuffer sb = new StringBuffer("zhangshan"); //通过构造，将StringBuffer转换为String String s1 = new String(sb); System.out.println(s1); //通过toString()将StringBuffer转换为String String s2 = sb.toString(); System.out.println(s2); //通过截取子字符串将StringBuffer转换为String String s3 = sb.substring(0,sb.length()); System.out.println(s3);

 

把数组转换成字符串

public static String arrayToString(int[] arr) { StringBuffer sb = new StringBuffer(); //创建字符串缓冲区对象 sb.append("["); //将[添加到缓冲区 //{1,2,3} for (int i = 0; i < arr.length; i++) { //遍历数组 //sb.append(arr[i] + ", "); //这样做没有] if(i == arr.length - 1) { sb.append(arr[i]).append("]"); //[1, 2, 3] }else { sb.append(arr[i]).append(", "); //[1, 2, } } return sb.toString(); }

 

 

StringBuffer与StringBuilder的区别

• StringBuffer是JDK1.0版本的，是线程安全的，效率低
• StringBuilder是JDK1.5版本的，是线程不安全的，效率高

 

String和StringBuffer、StringBuilder的区别

• String是一个不可变的字符序列
• StringBuffer和StringBuilder是可变的字符序列

 

* 基本数据类型的值传递，不改变其值

* 引用数据类型的值传递，改变其值

 

*String和StringBuffer分别作为值传递

*String虽然是引用型数据类型，但是它当作参数传递时和基本数据类型是一样的

public class Demo5 { public static void main(String[] args) { String s = "Stringzhangshan"; System.out.println(s); change(s); System.out.println(s); StringBuffer sb = new StringBuffer(); sb.append("StringBufferzhangshanshan"); System.out.println(sb); change(sb); System.out.println(sb); } public static void change(StringBuffer sb) { sb.append("idcast"); } public static void change(String s) { s += "idcast"; } }

 

 

数组高级冒泡排序：轻的上浮，沉的下浮

原理：两个相邻位置元素比较，如果前面的元素比后面的大就交换位置。

第一次：arr[0]与arr[1]，arr[1]与arr[2]，arr[2]与arr[3]，arr[3]与arr[4]，比较四次；

第二次：arr[0]与arr[1]，arr[1]与arr[2]，arr[2]与arr[3]，比较三次；

第三次：arr[0]与arr[1]，arr[1]与arr[2]，比较两次；

第四次：arr[0]与arr[1]，比较一次。

public class BubbleSort { public static void main(String[] args) { int arr[] = {23,55,24,74,40,99}; bubbleSort(arr); print(arr); } public static void bubbleSort(int[] arr) { int temp; for (int i = 0; i < arr.length-1; i++) { //外循环只需要进行length-1次 for (int j = 0; j < arr.length-1-i; j++) { //内循环每次只需要比较length-1-i次 if(arr[j]>arr[j+1]) { temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } public static void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } } }

 

 

数组高级选择排序：

原理：用一个索引位置上的元素，依次与其他索引位置上的元素比较，小的在前面，大的在后面。

第一次：arr[0]分别与arr[1-4]比较，比较4次；

第二次：arr[1]分别与arr[2-4]比较，比较3次；

第三次：arr[2]分别与arr[3-4]比较，比较2次；

第四次：arr[3]与arr[4]比较，比较1次；

public static void selectSort(int[] arr) { for (int i = 0; i < arr.length-1; i++) { for (int j = i+1; j < arr.length; j++) { if(arr[i]>arr[j]) { swap(arr,i,j); } } } } private static void swap(int arr[],int i,int j) { int temp; temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; }

 

 

二分查找：

前提：数组是有序的。

 

public class BinarySearch { public static void main(String[] args) { int arr[] = {12,24,35,44,55,72,97}; System.out.println(getIndex(arr,12)); } public static int getIndex(int arr[],int value) { int min = 0; int max = arr.length-1; int mid = (min + max) / 2; while(arr[mid]!=value) { //中间值不等于要查找的数，就开始循环 if(arr[mid]>value) { //如果中间值大于要查找的数 max=mid-1; //则最大索引发生改变 } else if(arr[mid]<value) { //如果中间值小于要找的值 min = mid+1; //则最小索引发生改变 } if(min>max) { //如果最小值大于最大值，则说明要找的值不存在，返回-1 return -1; } mid = (max+min)/2; //无论最大索引改变还是最小索引改变，中间索引都要发生改变 } return mid; } }

 

 

Array类：

• 针对数组进行操作额工具类
• 提供了排序查找等功能。

toString（int [] a）：将数组转换成字符串

sort（int [] a）：排序（API提供的是快速排序）。

binarySearch（int [] a, int key）：二分查找。

 

基本类型包装类

问：为什么会有基本类型包装类？

将基本数据类型封装成对象的好处在于 可以在对象中定义更多的功能方法操作该数据。

常用操作：用于基本数据类型与字符串之间的转换。

 

基本数据类型有八种，其中7种都有parseXxx（）方法，可以将这七种的字符串表现形式转换成基本数据类型。

char的包装类Character中没有parseXxx（）方法，字符串到字符的转换通过toCharArray()就可以把字符串转换成字符数组。

 

基本数据类型与包装类

对应：

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

 

Integer构造方法

public Integer(int value)

public Integer(String s)

 

String与int类型的相互转换

int---------->String

• 和“”拼接 (推荐使用)

int i = 100; String s1=i+"";

• public static String valueOf(int i) (推荐使用)

String s2=String.valueOf(i);

• int-------Integer-------String(Integer类的toString()方法)

Integer i2 = new Integer(i); String s3 = i2.toString();

• public static String toString(int i) (Integer类的静态方法)

String s4 = Integer.toString(i);

 

 

String--------->int

• String--------Integer--------int

String s="200"; Integer i3 = new Integer(s); //将Integer转换成int int i4 = i3.intValue();

• public static int parseInt(String s)

int i5 = Integer.parseInt(s); //推荐用这种

 

 

JDK5的新特性自动装箱和自动拆箱

自动装箱：把基本数据类型转换为包装类类型。

自动拆箱：把包装类类型转换为基本数据类型。

-128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新对象，而是从常量池中获取。如果超过了byte的取值范围，就会再创建新对象。