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

最新推荐文章于 2016-01-04 09:49:17 发布

maidou51

最新推荐文章于 2016-01-04 09:49:17 发布

阅读量383

点赞数

分类专栏： Java学习笔记文章标签： java 黑马程序员 string 集合 stringbuffer

本文链接：https://blog.csdn.net/maidou51/article/details/49910629

版权

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

20 篇文章 0 订阅

订阅专栏

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

字符串缓冲区：

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