黑马程序员——Java基础——集合（二）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

字符串缓冲区：

package cn.fu._03stringbuffer;
/**
* StringBuffer
* 字符串缓冲区,用于存储数据的容器
*
* 特点:
* 1.长度是可变的.
* 2.可以吃存储不同类型的数据.
* 3.最终要转成字符串进行使用.
*
* P.S.
* StringBuffer的字符串缓冲区初始容量为16个字符,其实质还是数组.
*
* 功能
* 1.添加
4000

* StringBuffer append(date);
* StringBuffer insert(index,data);
*
* 2.删除
* StringBuffer delete(int start,int end);包含头,不包含尾
* StringBuffer deleteCharAt(int index):删除指定的元素.
*/

public class StringBufferDemo1 {
public static void main(String[] args) {
bufferMethodDemo();
}
public static void bufferMethodDemo(){
//创建缓冲区对象
StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = sb1.append(4);
//先在sb1在缓冲区添加4,然后将sb2引用变量指向了最终生成的字符串对象,故两者指向同一个对象
System.out.println(sb1);//4
System.out.println(sb2);//4
System.out.println(sb1==sb2);//true

System.out.println(sb1.append(5));//45
System.out.println(sb1.append(6).append(7));//4567
System.out.println("-------------------------------");
StringBuffer sb = new StringBuffer();
sb.append(2).append(4);
sb.insert(1, "haha");//在1索引插入haha
System.out.println(sb.toString());//2haha4
System.out.println("===============================");
StringBuffer ssb = new StringBuffer("laskjdlasj");
ssb.delete(1, 3);//删除sk
System.out.println(ssb);//lkjdlasj
ssb.delete(0, ssb.length());//清空缓冲区
System.out.println(ssb);

}
}

输出结果：

4

4

true

45

4567

-------------------------------

2haha4

===============================

lkjdlasj

package cn.fu._03stringbuffer;
/**
* 3.查找
* char charAt(int index);根据索引查找字符
* int indexOf(String str);根据字符串查找索引
* int lastindexOf(String str);从末尾查找字符的索引
*
* 4.修改
* StringBuffer replace(int start,int end,String str);将start~end替换为str
* void setCharAt(int index,char ch);将index位置的字符替换为ch
*
* 5.其他方法
* void setLength(int newlength);设置字符序列的长度
* public StringBuffer reverse();将字符序列用其反转形式取代
*/

public class StringBufferDemo2 {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer("abcd");
System.out.println(sb1.charAt(1));//b
System.out.println(sb1.indexOf("bc"));//1
System.out.println(sb1.lastIndexOf("a"));//0
sb1.replace(1,2,"nba");//在1~2索引的字符替换为nba
System.out.println(sb1);//anbacd
sb1.setCharAt(2,'q');//将2索引的字符替换为q
System.out.println(sb1);//anqacd
System.out.println("=========================");
method();
}
public static void method(){
StringBuffer sb2 = new StringBuffer("1234");

sb2.setLength(2);
System.out.println(sb2);//12
System.out.println(sb2.length());//2

sb2.setLength(10);
System.out.println(sb2);//12
System.out.println(sb2.length());//10
System.out.println(sb2.reverse());//       21
System.out.println('\u0000');//
/*
* P.S.
* 1.使用setLength设置StringBuffer中字符序列的长度.
* 如果小于已有字符序列的长度,相当于清除缓冲区中的一部分内容.
* 如果大于已有字符序列的长度,相当于扩充缓冲区,扩充部分用空字符'\ u0000'填充.
* 2.当创建的StringBuffer内容长度大于16,将会新创建一个新数组,长度比旧数组长,
* 然后将数组内容拷贝到新数组,超出旧数组长度的内容将放在新数组的内容的后面,也可以
* 通过StringBuffer(int capacity);构造函数自己设置StringBuffer缓冲区长度.
*/
}
}

输出结果：

b

1

0

anbacd

anqacd

=========================

12

2

12

StringBulider：

package cn.fu._04stringbuilder;
/**
* StringBulider
* JDK1.5后出现,功能和StringBuffer一模一样
*
* 不同的是:
* StringBuffer是线程同步的,通常用于多线程.
* StringBuilder是线程不同步,通常用于单线程,它的出现能够提高程序效率.
* 故StringBuilder多用于多个线程是不安全的,如果需要这样的同步,建议用StringBuffer.
*/
/*
*P.S.JDK升级的目的:
*1.简化书写;
*2.提高效率;
*3.增加安全性.
*/
//示例:将一个int素组变成字符串
public class StringBuilderDemo1 {
public static void main(String[] args) {
int[] arr = {3,1,5,4,8};
String s = arrayToString(arr);
System.out.println(s);
}

private static String arrayToString(int[] arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
sb.append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(",");
}
}
return sb.toString();
}

}

输出结果：

[3,1,5,4,8]

基本数据类型int包装类Integer

package cn.fu._05Integer;
/**
* 常用对象:
* 基本数据类型包装类
* 为了方便操作基本数据类型,将其封装成了对象,在对象中定义了书写和行为丰富了该数据的操作.
* 用于描述该对象的类就称为基本数据类型的包装类.
* byte    Byte
* short   Short
* int     Integer
* long    Long
* float   Float
* double  Double
* char    Character
* boolean Boolean
* 该包装对象主要用于基本类型和字符串之间的转换
* 基本类--->字符串
* 1.基本类型的数值+""
* 2.用String类中的静态方法valueOf(基本类型数值);
*
* 字符串--->基本类型
* 1.使用包装类中的静态方法xxx parseXxx("xxx");
* int parseInt(String str);
* long parseLong(String str);
* boolean ParseBoolean(String str);
* 只有character没有parse方法.(但是有toCharArray(),charAt())
* 2.如果字符串被Intege进行对象的封装,可以使用另一个非静态的方法,intValue.
* 将一个Integer对象转换成基本类型数据.
* 3.用Integer的静态方法valueOf(String s)
*
* 整数具备不同的进制体现.
* 十进制--->其他进制方法:
* String toBinaryString(int i);
* String toOctalString(int i);
* String toHexString(int i);
* String to String(int i,int radix);
*
* 其他进制--->十进制方法:
* int parseInt(String s, int radix);
*/

public class IntegerDemo {
public static void main(String[] args) {
//整型最大值
System.out.println(Integer.MAX_VALUE);//2147483647
//十进制转换成二进制
System.out.println(Integer.toBinaryString(6));
Integer i = new Integer(5);//110
System.out.println(Integer.parseInt("123")+i);//128
if(Boolean.parseBoolean("true")){
System.out.println("true");//true
}
Integer i2 = new Integer("123");
System.out.println(i2.intValue());//123
System.out.println("===========================");
//十进制转换其他进制
System.out.println(Integer.toBinaryString(17));//10001
System.out.println(Integer.toOctalString(17));//21
System.out.println(Integer.toHexString(17));//11
System.out.println(Integer.toString(17, 4));//101
System.out.println("===========================");
//其他进制转换为十进制
System.out.println(Integer.parseInt("10",2));//2 (前面的参数表示数组大小,后面的参数表示前面的参数的进制)
System.out.println(Integer.parseInt("aba",16));//2746
}
}

输出结果:

2147483647

110

128

true

123

===========================

10001

21

11

101

===========================

2

2746

package cn.fu._05Integer;
/**
* 需求:对一个字符串中的数值进行从小到大的排序。
* "20 78 9 -7 88 36 29"
*
* 分析:
* 1.将字符串切割为字符数组
* 2.将字符数组转行为Int数组
* 3.对Int数组进行排序
* 4.将Int数组转换为StringBuilder对象
* 5.使用toString方法返回排序后的新字符串
*/

public class IntegerDemo2 {
public static void main(String[] args) {
String s = "20 78 9 -7 88 36 29";
System.out.println(s);
//1.将字符串切割为字符数组
String[] stringArray = s.split(" +");
//2.将字符数组转行为Int数组
int[] intArray = new int[stringArray.length];//建立相同长度的int数组
for (int i = 0; i < intArray.length; i++) {
intArray[i]=Integer.parseInt(stringArray[i]);
}
//3.对Int数组进行排序
int temp=0;
for (int i = 0; i < intArray.length-1; i++) {
for (int j = i+1; j < intArray.length; j++) {
if(intArray[i]>intArray[j]){
temp = intArray[i];
intArray[i] = intArray[j];
intArray[j] = temp;
}
}
}
//4.将Int数组转换为StringBuilder对象
StringBuilder sb = new StringBuilder();
for (int i = 0; i < intArray.length; i++) {
sb.append(intArray[i]+" ");
}
//5.使用toString方法返回排序后的新字符串
String ss = sb.toString();
System.out.println(ss);
}
}

输出结果:

20 78 9 -7 88 36 29

-7 9 20 29 36 78 88