20211110 day13 String、StringBuffer类、数组排列

最新推荐文章于 2024-09-15 19:46:31 发布

period000

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量4.2k

点赞数

分类专栏： 2021-10-19 文章标签： 1024程序员节 java 开发语言

本文链接：https://blog.csdn.net/period000/article/details/121374724

版权

2021-10-19 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

day13目录：

13.02_常见对象(StringBuffer类的构造方法)(掌握)

A:StringBuffer的构造方法：
	public StringBuffer():				无参构造方法
	public StringBuffer(int capacity):	指定容量的字符串缓冲区对象
 	public StringBuffer(String str):		指定字符串内容的字符串缓冲区对象

	B:StringBuffer的方法：
		public int capacity()：返回当前容量。	理论值
		public int length():返回长度（字符数）。 实际值
	C:案例演示
		构造方法和长度方法的使用

13.03_常见对象(StringBuffer的添加功能)(掌握)

A:StringBuffer的添加功能
	public StringBuffer append(String str):			可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
	public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
B:案例演示
	StringBuffer的添加功能

A:  public static void main(String[] args) {
//  StringBuffer 就是一长度可变的字符容器，如果你有拼串的需求，可以采用字符容器来拼串。
    
	/*StringBuffer()
    构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。*/
	/*StringBuffer(6),表示初始容量为6个字节。*/
	
    StringBuffer sb = new StringBuffer();
    int capacity = sb.capacity();
    System.out.println(capacity);

    sb.append("我自己的改变练力量");
    sb.append("de");
    System.out.println(sb);
	｝

13.04_常见对象(StringBuffer的删除功能)(掌握)

A:StringBuffer的删除功能
	public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
	public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
B:案例演示
	StringBuffer的删除功能
	

	public static void main(String[] args) {
    StringBuffer sb = new StringBuffer();
    sb.append("西部开源教育科技有限公司");
    //deleteCharAt(0) 根据索引，每次删除容器中的一个字符，返回的还是容器本身
    sb.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0).deleteCharAt(0);
    //sb.delete(0, 4); 根据起始索引，和终止索引，删除容器中一段内容，返回的还是容器本身，索引，含头不含尾
    sb.delete(0, 4);
    System.out.println(sb.toString());
}

13.05_常见对象(StringBuffer的替换和反转功能)(掌握)

A:StringBuffer的替换功能
	public StringBuffer replace(int start,int end,String str):	从start开始到end用str替换
B:StringBuffer的反转功能
	public StringBuffer reverse():							字符串反转
C:案例演示
	StringBuffer的替换和反转功能

	public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("西部开源教育科技有限公司");
    int i = sb.indexOf("西部5555");
    System.out.println(i);
    //根据起始索引和终止索引，替换容器中的一段内容，返回的还是容器本身，索引，含头不含尾。
    sb.replace(0, 4, "好好休息");
    //反转容器中的内容，返回的还是容器本身
    sb.reverse();
    System.out.println(sb);
}




    从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
	      int indexOf (String str)  
	  从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
	   int indexOf (String str,int fromIndex)	
 
  从后往前找
   int lastIndexOf (String str)
     
   int lastIndexOf (String str,int fromIndex) 

	public static void main(String[] args) {
    String Str = new String("字符截取:www.runoob.com");
    String Substr1 = new String("runoob");
    String Substr2 = new String("com");

    System.out.println("查找字符 o 最后出现的位置：");
    System.out.println(Str.lastIndexOf('o'));
    System.out.println("从第14个位置查找字符 o 最后出现的位置：");
    System.out.println(Str.lastIndexOf('o',14));
    System.out.println("字符串 SubStr1 最后出现的位置：");
    System.out.println(Str.lastIndexOf( Substr1));
    System.out.println( Substr1);
    System.out.println("从第十五个位置开始搜索字符串 SubStr1最后出现的位置：");
    System.out.println(Str.lastIndexOf(Substr2,15));
    System.out.println("字符串 SubStr2 最后出现的位置：");
    System.out.println(Str.lastIndexOf( Substr2 ));
    System.out.println(Substr2);

输出结果
查找字符 o 最后出现的位置：
17
从第14个位置查找字符 o 最后出现的位置：
13
字符串 SubStr1 最后出现的位置：
9
runoob
从第十五个位置开始搜索字符串 SubStr1最后出现的位置：
-1
字符串 SubStr2 最后出现的位置：
16
com

13.06_常见对象(StringBuffer的截取功能及注意事项)(掌握)

A:StringBuffer的截取功能
	public String substring(int start):			从指定位置截取到末尾
	public String substring(int start,int end):	截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
B:注意事项
	注意:返回值类型不再是StringBuffer本身
C:案例演示
	StringBuffer的截取功能及注意事项


public static void main(String[] args) {
    String str = "Helloworld";
    String sub = str.substring(0,3);
    System.out.println(sub);
}

显示结果Hel

13.07_常见对象(StringBuffer和String的相互转换)(掌握)

A:String -- StringBuffer
	a:通过构造方法
	b:通过append()方法

public static void main(String[] args) {
    String str="abc";
    StringBuffer sb = new StringBuffer(str);
    StringBuffer sb2 = new StringBuffer(str).append(01); /*/abd占用0索引位置*/
    StringBuffer sb3 = new StringBuffer(str).insert(1,str);
    System.out.println(sb);
    System.out.println(sb2);
    System.out.println(sb3);
    System.out.println("====================================");

输出结果
abc
abc1
aabcbc

B:StringBuffer -- String
	a: 使用substring方法
	b:通过构造方法
	c:通过toString()方法
C:案例演示
	StringBuffer和String的相互转换

public static void main(String[] args) {
//StringBuffer---------------String
    StringBuffer sb4 = new StringBuffer();
    sb4.append(100).append(3.14).append(false);
    //方式1
    String s = sb4.toString(); //"1003.14false"
    System.out.println(s);
    //方式2
    String s1 = sb4.substring(1);
    System.out.println(s1);
    //方式3
   /* String(StringBuffer buffer)
    分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。*/

    String s2 = new String(sb4);
    System.out.println(s2);
}

输出结果：
1003.14false
003.14false
1003.14false

13.08_常见对象(把数组转成字符串)(掌握)

A:案例演示
	需求：把数组中的数据按照指定个格式拼接成一个字符串
		举例：
			int[] arr = {1,2,3};	
		输出结果：
			"[1, 2, 3]"
	用StringBuffer的功能实现

	public static void main(String[] args) {
    int[] arr = {1, 2, 3,4,5,6};
    StringBuffer sb = new StringBuffer("*【");
    for (int i = 0; i < arr.length; i++) {
        if(i==arr.length-1){
            sb.append(arr[i]).append("】*");
        }
        else{
            sb.append(arr[i]).append(",");
        }
    }
    String s = sb.toString();
    System.out.println(s);
}

输出结果
【1,2,3,4,5,6】

13.09_常见对象(字符串反转)(掌握)

A:案例演示
	需求：把字符串反转
		举例：键盘录入"abc"		
		输出结果："cba"
	用StringBuffer的功能实现	

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一段字符串");
    String s = sc.nextLine();
    String s1 = new StringBuffer(s).reverse().toString();
    System.out.println(s1);
}

输出结果
请输入一段字符串
abc
cba

13.10_常见对象(StringBuffer和StringBuilder的区别)(掌握)

A:StringBuilder的概述
	通过查看API了解一下StringBuilder类
B:面试题
	String,StringBuffer,StringBuilder的区别

String
String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量优先的内存空间。
不可变

StringBuffer
StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量
可变线程安全多线程从左字符串

StringBuilder
可变类，速度更快
可变线程不安全单线程操作字符串

13.11_常见对象(String和StringBuffer分别作为参数传递)(掌握)

A:形式参数问题
	String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型属于值传递
	StringBuffer作为参数传递 
B:案例演示
	String和StringBuffer分别作为参数传递问题

参数传递：
基本类型，作为参数传递，属于值传递，形参的改变，不影响实参。
引用类型，作为参数产地，属于引用传递，传递的地址值，形参的改变，会影响实参。
String类型，虽说是引用数据类型，但是他作为参数传递，属于值传递，传递的是字符串的值，形参的改变，不影响实参。

public static void main(String[] args) {
    String str="哈哈";
    test(str);
    System.out.println(str);
    
    StringBuffer sb = new StringBuffer("星星");
    test(sb);
    System.out.println(sb.toString());
}

public static void test(String s1) {
    s1+="呵呵";
    System.out.println(s1);
}

public  static void test(StringBuffer sb) {
    sb.append("哈哈哈啦");
    sb.reverse();
    System.out.println(sb);
}

输出结果
System.out.println(s1); //哈哈呵呵
System.out.println(str); //“哈哈”
System.out.println(sb.toString()); //“啦哈哈哈星星”
System.out.println(sb.toString()); //“啦哈哈哈星星”

补充：StringJoiner

StringJoiner(CharSequence delimiter) 
构建了一个字符容器，指定分隔符 

StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 
构建了一个字符容器，指定分隔符，前缀，后缀

StringJoiner add(CharSequence newElement) 
增加了一份给 CharSequence值的 StringJoiner价值的下一个元素。  
int length() 
返回该 StringJoiner的 String表示长度。 

String toString()  把容器中的数据以字符串返回

public static void main(String[] args) {
    //指定分隔符
    StringJoiner joiner = new StringJoiner("=");
    joiner.add("aaaa").add("bbbb").add("ccc");
    String s = joiner.toString();
    System.out.println(s);
    //构建了一个字符容器，指定分隔符，前缀，后缀
    StringJoiner joiner2 = new StringJoiner(",", "[", "]");
    int[] arr = {1, 2, 3, 4, 5, 6};
    for (int i = 0; i < arr.length; i++) {
        joiner2.add(String.valueOf(arr[i]));
    }
    System.out.println(joiner2.toString());
}

输出结果
AAAA=BBBB=CCCC
[1,2,3,4,5,6]

13.12_常见对象(数组高级冒泡排序原理图解)(掌握)

A:画图演示
	需求：
		数组元素：{24, 69, 80, 57, 13}
		请对数组元素进行排序。
		
B:冒泡排序原理
		相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
public static void main(String[] args) {
    int[] arr = {24, 69, 80, 57, 13, 0, 2, 39};
}

private static void tuiDao(int[] arr) {
    for  (int i=0;i< arr.length-1-0;i++) {
        if(arr[i]>arr[i+1]) {
            int t =arr[i];
            arr[i]=arr[i+1];
            arr[i+1]=t;
//         	System.out.println(arr[t]);
        }
    }

13.13_常见对象(数组高级冒泡排序代码实现)(掌握)

A:案例演示
	数组高级冒泡排序代码

13.14_常见对象(数组高级选择排序原理图解)(掌握)

A:画图演示
	需求：
		数组元素：{24, 69, 80, 57, 13}
		请对数组元素进行排序。
		
B:选择排序原理
		从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

13.15_二分查找

A:画图演示
B:二分查找：前提数组元素必须有序   
C:二分查找的思想：每一次都查中间索引的那个元素，比较大小就能减少一半的元素。

 注意:二分查找不是找该元素第一次出现的索引。
 比如下面这个数组，找4元素的索引，找出来的索引是5
 int[] arr = {1,2,3,4,4,4,6,7,8,9,10};
 
 
基本查询：从头开始挨个往后找，该元素第一次出现的索引。

13.18_常见对象(Arrays类的概述和方法使用)(掌握)

A:Arrays类概述
	针对数组进行操作的工具类。
	提供了排序，查找等功能。
B:成员方法
	public static String toString(int[] a)
	public static void sort(int[] a)
	public static int binarySearch(int[] a,int key)
	static boolean equals(int[] a, int[] a2) 比较两个数组中的元素，是否一样
    static int[] copyOf(int[] original, int newLength)  复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
    static int[] copyOfRange(int[] original, int from, int to) 复制旧数组中的指定范围间的几个元素到新数组中 from 起始索引 to 终止索引
    
	C:案例演示	
	通过Arrays类的功能来进排序和查找

13.19_常见对象(Arrays类的源码解析)(掌握)

A:源码解析
	public static String toString(int[] a)
B:源码解析
	public static int binarySearch(int[] a,int key)

13.20_常见对象(基本类型包装类的概述)(掌握)

A: 需求:
	a:将100转换成二进制 , 八进制 , 十六进制
	b:判断一个数是否在int的范围内
B:为什么会有基本类型包装类
	为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
C:常用操作:	常用的操作之一：用于基本数据类型与字符串之间的转换。
D:基本类型和包装类的对应
	byte 			Byte
	short			Short
	int			Integer
	long			Long
	float			Float
	double		        Double
	char			Character
	boolean		         Boolean

13.21_常见对象(Integer类的概述和构造方法)(掌握)

A:Integer类概述
	通过JDK提供的API，查看Integer类的说明

	Integer 类在对象中包装了一个基本类型 int 的值,
	该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
	还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
	public Integer(int value)
	public Integer(String s)  //要个一个字面上是数字的字符串，如果不是就会报错
C:案例演示
	使用构造方法创建对象

13.22_常见对象(String和int类型的相互转换)(掌握)

A:int -- String
	a:和""进行拼接
	b:public static String valueOf(int i)
	c:int -- Integer -- String
	d:public static String toString(int i)
B:String -- int
	a:String -- Integer -- intValue();
	b:public static int parseInt(String s)
C:案例演示	
	String和int类型的相互转换

13.23_常见对象(JDK5的新特性自动装箱和拆箱)(掌握)

A:JDK5的新特性
	自动装箱：把基本类型转换为包装类类型
	自动拆箱：把包装类类型转换为基本类型
B:案例演示
	JDK5的新特性自动装箱和拆箱
	Integer ii = 100;
	ii += 200;
C:注意事项
	在使用时，Integer  x = null;代码就会出现NullPointerException。
	建议先判断是否为null，然后再使用。

13.24_常见对象(Integer的面试题)(掌握)

A:Integer的面试题
	看程序写结果
	
	Integer i1 = new Integer(127);
	Integer i2 = new Integer(127);
	System.out.println(i1 == i2);
	System.out.println(i1.equals(i2));
	System.out.println("-----------");

	Integer i3 = new Integer(128);
	Integer i4 = new Integer(128);
	System.out.println(i3 == i4);
	System.out.println(i3.equals(i4));
	System.out.println("-----------");

	Integer i5 = 128;
	Integer i6 = 128;
	System.out.println(i5 == i6);
	System.out.println(i5.equals(i6));
	System.out.println("-----------");

	Integer i7 = 127;
	Integer i8 = 127;
	System.out.println(i7 == i8);
	System.out.println(i7.equals(i8));

###13.25_day13总结