eclipse的使用和常用API-3

墨蓝 2022-07-29 10:51 142阅读 0赞

**eclipse的使用和常用API-3**

**1.StringBuffer类的概述**

\* A:StringBuffer类概述

\*通过JDK提供的API，查看StringBuffer类的说明

\*线程安全的可变字符序列,执行同步,安全,但效率相对低

\* B:StringBuffer和String的区别

\*String是一个不可变的字符序列

\*StringBuffer是一个可变的字符序列

//线程安全效率低,线程不安全效率高.

//从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

**2.StringBuffer类的构造方法**

\* A:StringBuffer的构造方法：

\*public StringBuffer():无参构造方法,构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符

StringBuffersb = new StringBuffer();

System.out.println(sb.length());                         //容器中的字符个数,实际值

System.out.println(sb.capacity());                     //容器的初始容量,理论值

\*public StringBuffer(int capacity):指定容量的字符串缓冲区对象,具有指定初始容量的字符串缓冲区

StringBuffersb2 = new StringBuffer(10);

System.out.println(sb2.length()); //0

System.out.println(sb2.capacity());  //10

\*public StringBuffer(String str):指定字符串内容的字符串缓冲区对象, 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

StringBuffersb3 = new StringBuffer("heima");

System.out.println(sb3.length());   //0             //实际字符的个数

System.out.println(sb3.capacity());         //21           //字符串的length + 初始容量

\* B:StringBuffer的方法：

\*public int capacity()：返回当前容量。        //初始容量,理论值(不掌握)

\*public int length():返回长度（字符数）。实际值即容器中的字符数

**3.StringBuffer的添加功能**

\* A:StringBuffer的添加功能  append:追加

\*public StringBuffer append(String str):

\*可以把任意类型数据追加到字符串缓冲区里面,并返回字符串缓冲区本身

//StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组,当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区追加字符

StringBuffersb = new StringBuffer();

StringBuffersb2 = sb.append(true);

StringBuffersb3 = sb.append("heima");

StringBuffersb4 = sb.append(100);

\*public StringBuffer insert(int offset,String str):

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

StringBuffersb = new StringBuffer("1234");

sb.insert(3,"heima");      //在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常

System.out.println(sb);        //123heima4

**4.StringBuffer的删除功能**

\* A:StringBuffer的删除功能

\*public StringBuffer deleteCharAt(int index):

\*删除指定位置的字符，并返回本身

\*public StringBuffer delete(int start,int end):

\*删除从指定位置开始指定位置结束的内容，并返回本身,也是左闭右开

\*演示:

public static void main(String\[\] args) \{

StringBuffersb = new StringBuffer();

//sb.deleteCharAt(5);      //当缓冲区中这个索引上没有元素的时候就会报StringIndexOutOfBoundsException

sb.append("heima");

//sb.deleteCharAt(4);      输出 heim, //根据索引删除掉索引位置上对应的字符

//sb.delete(0,2);  输出im    //删除的时候是包含头,不包含尾

//System.out.println(sb);

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

//System.out.println(sb);

sb= new StringBuffer();   //不要用这种方式清空缓冲区,原来的会变成垃圾,浪费内存

System.out.println(sb);

**5.StringBuffer的替换和反转功能**

\* A:StringBuffer的替换功能

\*public StringBuffer replace(int start,int end,String str):

\*从start开始到end用str替换,也是左闭右开

\* B:StringBuffer的反转功能

\*public StringBuffer reverse():

\*字符串反转

\*演示:

public static void main(String\[\] args) \{

StringBuffersb = new StringBuffer("heima");

//sb.replace(0,3, "bai");                   //替换

//System.out.println(sb);   //baima

sb.reverse();

System.out.println(sb);    //amiab

**6.(StringBuffer的截取功能及注意事项**

\* A:StringBuffer的截取功能

\*public String substring(int start):

\*从指定位置截取到末尾

\*public String substring(int start,int end):

\* 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

\* B:注意事项

\*注意:返回值类型不再是StringBuffer本身,是String类型,所以应该用string去接收

\*演示:

public static void main(String\[\] args) \{

StringBuffersb = new StringBuffer("woaiheima");

//Stringstr = sb.substring(4);     //用string类型去接收

//System.out.println(str);        //heima

//System.out.println(sb);       //woaiheima    注意!!!!!  只是将截取的内容用string类型返回,并没有修改stringBuffer对象

Stringstr3 = sb.substring(4, 7);

System.out.println(str3);      //hei

**7.StringBuffer和String的相互转换**

\* A:String -- StringBuffer

\*a:通过构造方法

\*b:通过append()方法

StringBuffer sb1 = new StringBuffer("heima");//通过构造方法将字符串转换StringBuffer对象

System.out.println(sb1);

StringBuffer sb2 = new StringBuffer();

sb2.append("heima");                 //通过append方法将字符串转换为StringBuffer对象

System.out.println(sb2);

\* B:StringBuffer -- String

\*a:通过构造方法

\*b:通过toString()方法

\*c:通过subString(0,length);

StringBuffersb = new StringBuffer("heima");

Strings1 = new String(sb);       //通过构造将StringBuffer转换为String

System.out.println(s1);

Strings2 = sb.toString(); //通过toString方法将StringBuffer转换为String

System.out.println(s2);

Strings3 = sb.substring(0, sb.length());  //通过截取子字符串StringBuffer转换为String

System.out.println(s3);

**8.把数组转成字符串**

\* A:案例演示, 需求：把数组中的数据按照指定个格式拼接成一个字符串

举例：

int\[\]arr = \{1,2,3\};

输出结果：

"\[1,2, 3\]"

用StringBuffer的功能实现

\*分析:

就是遍历这个数组然后调用append方法向缓冲区中添加元素,最后调用tostring方法转换成字符串,输出;  和string相比用stringBuffer更好,因为用string是会在常量池中不断的产生垃圾,而stringBuffer只有一个对象,不产生过多的垃圾.

publicstatic void main(String\[\] args) \{

int\[\]arr = \{1,2,3\};

System.out.println(arrayToString(arr));

publicstatic String arrayToString(int\[\] arr) \{

StringBuffersb = 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,

returnsb.toString();

//变量和字符串常量相加的时候,系统会在底层,创建StringBuffer,然后在调用tostring

**9.字符串反转**

\* A:案例演示:

需求：把字符串反转

举例：键盘录入"abc"

输出结果："cba"

用StringBuffer的功能实现

\*分析:

直接调用reverse()方法

将其封装成方法,上面例子也要封装成方法

publicstatic String revString(String line) \{

StringBuffersb = new StringBuffer(line);

sb.reverse();             //将缓冲区的内容反转

return sb.toString();

在主方法中调用直接:System.out.println(revString(line));

**10.StringBuffer和StringBuilder的区别**

\* A:StringBuilder的概述

\*通过查看API了解一下StringBuilder类

\* B:面试题

\*String,StringBuffer,StringBuilder的区别

\*StringBuffer和StringBuilder的区别

\*StringBuffer是jdk1.0版本的,是线程安全的,效率低

\*StringBuilder是jdk1.5版本的,是线程不安全的,效率高

\*String和StringBuffer,StringBuilder的区别

\*String是一个不可变的字符序列

\*StringBuffer,StringBuilder是可变的字符序列

**11.String和StringBuffer分别作为参数传递**

\* A:形式参数问题

\*String作为参数传递

\*StringBuffer作为参数传递

\* B:案例演示

\*String和StringBuffer分别作为参数传递问题

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

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

string是不可变的字符序列!!!!!!!!!!

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

publicstatic void main(String\[\] args) \{

Strings = "heima";

System.out.println(s);  //heima

change(s);

System.out.println(s);  //heima

System.out.println("---------------------");

StringBuffersb = new StringBuffer();

sb.append("heima");

System.out.println(sb);  //heima

change(sb);

System.out.println(sb);  //heimaitcast

publicstatic void change(StringBuffer sb) \{

sb.append("itcast");     /

publicstatic void change(String s) \{

s+= "itcast";      //调用这个方法的时候会在常量池新建一个字符串heimaitcast,然后将它的地址赋值给change方法的变量s,当调用完change方法后,弹栈,就会变成垃圾,但主方法里的变量s指向的地址没变

**12.数组高级冒泡排序原理图解**

\* A需求：

数组元素：\{24, 69, 80, 57,13\}

请对数组元素进行排序。

冒泡排序:

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处,最大值之后便不再参与比较

publicstatic void main(String\[\] args) \{

int\[\]arr = \{24, 69, 80, 57, 13\};

bubbleSort(arr);

//selectSort(arr);

print(arr);

\* 冒泡排序

第一次:arr\[0\]与arr\[1\],arr\[1\]与arr\[2\],arr\[2\]与arr\[3\],arr\[3\]与arr\[4\]比较4次

第二次:arr\[0\]与arr\[1\],arr\[1\]与arr\[2\],arr\[2\]与arr\[3\]比较3次

第三次:arr\[0\]与arr\[1\],arr\[1\]与arr\[2\]比较2次

第四次:arr\[0\]与arr\[1\]比较1次

publicstatic void bubbleSort(int\[\] arr) \{

for(int i = 0; i < arr.length - 1; i++) \{ //外循环只需要比较arr.length-1次就可以了

for(int j = 0; j < arr.length - 1 - i; j++) \{  //-1为了防止索引越界,-i为了提高效率

if(arr\[j\]> arr\[j+1\]) \{

/\*inttemp = arr\[j\];

arr\[j\]= arr\[j + 1\];

arr\[j+1\]= temp;\*/

swap(arr,j,j+1);

\}        \}        \}        \}

\* 打印数组

publicstatic void print(int\[\] arr) \{

for(int i = 0; i < arr.length; i++) \{

System.out.print(arr\[i\]+ " ");

**13.数组高级选择排序原理图解**

\* A:画图演示:需求：

\*数组元素：\{24, 69, 80, 57, 13\}

\*请对数组元素进行排序。

\*选择排序

\* 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处,最小值之后便不再参与比较

\* 选择排序:

\* 1,返回值类型void ,因为操作的是元数组,所以返回值类型是void

\* 2,参数列表int\[\] arr

第一次:arr\[0\]分别与arr\[1-4\]比较,比较4次

第二次:arr\[1\]分别与arr\[2-4\]比较,比较3次

第三次:arr\[2\]分别与arr\[3-4\]比较,比较2次

第四次:arr\[3\]与arr\[4\]比较,比较1次

publicstatic void selectSort(int\[\] arr) \{

for(int i = 0; i < arr.length - 1; i++) \{          //只需要比较arr.length-1次

for(int j = i + 1; j < arr.length; j++) \{

if(arr\[i\]> arr\[j\]) \{

/\*inttemp = arr\[i\];

arr\[i\]= arr\[j\];

arr\[j\]= temp;\*/

swap(arr,i,j);

\}        \}        \}        \}

\* 换位操作:

\* 如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的

privatestatic void swap(int\[\] arr,int i,int j) \{

inttemp = arr\[i\];

arr\[i\]= arr\[j\];

arr\[j\]= temp;

**14.数组高级二分查找原理图解**

\* A:画图演示

\*二分查找的前提：数组元素有序

publicstatic void main(String\[\] args) \{

int\[\]arr = \{11,22,33,44,55,66,77\};

System.out.println(getIndex(arr,22));

System.out.println(getIndex(arr,66));

System.out.println(getIndex(arr,88));

\* 二分查找

\* 1,返回值类型,int

\* 2,参数列表int\[\] arr,intvalue

publicstatic int getIndex(int\[\] arr, int value) \{

intmin = 0;

intmax = arr.length - 1;

intmid = (min + max) / 2;

while(arr\[mid\]!= value) \{          //当中间值不等于要找的值,就开始循环查找

if(arr\[mid\]< value) \{                   //当中间值小于了要找的值

min= mid + 1;           //最小的索引改变

\}elseif (arr\[mid\] > value)\{           //当中间值大于了要找的值

max= mid - 1;           //最大的索引改变

mid= (min + max) / 2;               //无论最大还是最小改变,中间索引都会随之改变

if(min> max) \{           //如果最小索引大于了最大索引,就没有查找的可能性了

return-1; //返回-1

returnmid;

\* B:注意事项

\*如果数组无序，就不能使用二分查找。

\*因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

**15.Arrays类的概述和方法使用**

\* A:Arrays类概述

\*针对数组进行操作的工具类。

\*提供了排序，查找等功能。

\* B:成员方法

\*public static String toString(int\[\] a) //数组转字符串

\*public static void sort(int\[\] a)   //排序

\*public static int binarySearch(int\[\] a,int key) //二分查找法

\*例:

publicstatic void main(String\[\] args) \{

int\[\]arr = \{33,22,11,44,66,55\};

System.out.println(Arrays.toString(arr));  //数组转字符串\[33,22,11,44,66,55\]

Arrays.sort(arr);      //排序

System.out.println(Arrays.toString(arr));  //\[11,22,33,44,55,66\]

int\[\]arr2 = \{11,22,33,44,55,66\};

System.out.println(Arrays.binarySearch(arr2,22));  //1

System.out.println(Arrays.binarySearch(arr2,66));  //5

System.out.println(Arrays.binarySearch(arr2,12));  //-2,找不到返回-插入点-1,输出结果加一在取正就得到了插入点

System.out.println(Arrays.binarySearch(arr2,88));  //-7

**17.基本类型包装类的概述**

\* A:为什么会有基本类型包装类

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

\* B:常用操作

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

\* C:基本类型和包装类的对应\*

byte                           Byte

short                           Short

int                                Integer

long                    Long

float                   Float

double                         Double

char                    Character

boolean                      Boolean

@@基本数据类型定义成包装类,有了类就可以创建对象,有了对象以后,里面就可以定义一些方法,有了方法之后我们直接去调用一定的方法就好了,对里面的操作就变的更加方面了

**18.Integer类的概述和构造方法**

\* A:Integer类概述

\*通过JDK提供的API，查看Integer类的说明

\*Integer 类在对象中包装了一个基本类型 int 的值,

\*该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，

\*还提供了处理 int 类型时非常有用的其他一些常量和方法

\* B:构造方法

\*public Integer(int value)

\*public Integer(String s)  @@参数放的是字符串的int值,s得是数字字符串

\* C:案例演示,使用构造方法创建对象

publicstatic void main(String\[\] args) \{

System.out.println(Integer.MAX\_VALUE);//int类型数的最大值

System.out.println(Integer.MIN\_VALUE);//int类型数的最小值

Integeri1 = new Integer(100);

System.out.println(i1);  //100

//Integeri2 = new Integer("abc");//java.lang.NumberFormatException数字格式异常

//System.out.println(i2);  //因为abc不是数字字符串,所以转换会报错

Integeri3 = new Integer("100");

System.out.println(i3);  //也是100

**19.String和int类型的相互转换**

\* A:int -- String

\*a:和""进行拼接

inti = 100;

Strings1 = i + "";      //推荐用,写法简单

\*b:public static String valueOf(int i)

inti = 100;

Strings2 = String.valueOf(i);    //推荐用,valueOf可以将任意类型转成字符串

\*c:int -- Integer -- String(Integer类的toString方法())

inti = 100;

Integeri2 = new Integer(i);

Strings3 = i2.toString();

\*d:public static String toString(int i)(Integer类的静态方法)

Strings4 = Integer.toString(i);

\* B:String -- int

\*a:String -- Integer -- int

Strings = "200";

Integeri3 = new Integer(s);

inti4 = i3.intValue();            //将Integer转换成了int数,麻烦

\*public static int parseInt(String s)

inti5 = Integer.parseInt(s);  //将String转换为int,推荐用这种

@@ 基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型 (char类型的包装类中没有parseXxx方法)

Strings1 = "true";  //布尔类型的字符串

booleanb = Boolean.parseBoolean(s1);  //将布尔类型的字符串转换成布尔类型

System.out.println(b);  //输出true

\------------------------------------------------------------------

@@                //String s2 = "abc";

//charc = Character.p     //char的包装类Character中没有pareseXxx的方法

//字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组

** **

**20.JDK5的新特性自动装箱和拆箱**

\* A:JDK5的新特性

\*自动装箱：把基本类型转换为包装类类型

\*自动拆箱：把包装类类型转换为基本类型

\* B:案例演示, JDK5的新特性自动装箱和拆箱

\*Integer ii = 100;

\*ii += 200;

\* C:注意事项

\*在使用时，Integer  x = null;代码就会出现NullPointerException。

\*建议先判断是否为null，然后再使用。

@@代码演示:

intx = 100;                      // 1

//               Integeri1 = new Integer(x);    //将基本数据类型包装成对象,装箱 2

//               inty = i1.intValue(); //将对象转换为基本数据类型,拆箱  3

Integeri2 = 100;      //自动装箱,把基本数据类型转换成对象  包含了 1和2

intz = i2 + 200;         //自动拆箱,把对象转换为基本数据类型  包含了 3

System.out.println(z);   //输出300.说明引用数据类型的i2变成了基本数据类型的100

Integeri3 = null;      //null没有记录任何对象,就是空指针

inta = i3 + 100;         //底层用i3调用intValue,但是i3是null,相当于用null去调用方法,就出现了空指针异常java.lang.NullPointerException

System.out.println(a);     //空指针异常java.lang.NullPointerException

\-------------------------------------------------------------------------------------------

**21.Integer的面试题**

\* A:Integer的面试题,看程序写结果:

Integeri1 = new Integer(97);

Integeri2 = new Integer(97);

System.out.println(i1== i2);   //false ,比较的是地址值

System.out.println(i1.equals(i2));//true

System.out.println("-----------");

Integeri3 = new Integer(197);

Integeri4 = new Integer(197);

System.out.println(i3== i4);  //false

System.out.println(i3.equals(i4));  //true

System.out.println("-----------");

Integeri5 = 97;

Integeri6 = 97;

System.out.println(i5== i6);  //true

System.out.println(i5.equals(i6));  //true

System.out.println("-----------");

Integeri7 = 197;

Integeri8 = 197;

System.out.println(i7== i8);  //true

System.out.println(i7.equals(i8));  true

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

\* 如果超过了byte取值范围就会再新创建对象,Integer i1 = new Integer(x);       //将基本数据类型包装成对象,超过了两次都是创建新对象.

发表评论取消回复

表情：

评论列表（有 0 条评论，142人围观）

eclipse的使用和常用API-3

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 selenium常用API的使用

相关快速使用Vue3最新的15个常用API

相关 eclipse的使用和常用API-4

相关 eclipse的使用和常用API-3

相关 eclipse的使用和常用API-2

相关 clipse的使用和常用API

相关 Redis常用API-使用文档

相关 Redis常用API-使用文档

相关 selenium常用api使用

相关 eclipse的项目使用和常用设置大全