JAVASE基础-day13（常见对象（StringBuffer，StringBuilder,Arrays，Integer））
2017-02-06 15:29
459 查看
13.01_常见对象(StringBuffer类的概述)
A:StringBuffer类概述通过JDK提供的API，查看StringBuffer类的说明
线程安全的可变字符序列
B:StringBuffer和String的区别
String是一个不可变的字符序列
StringBuffer是一个可变的字符序列
13.02_常见对象(StringBuffer类的构造方法)
A:StringBuffer的构造方法：public StringBuffer():无参构造方法
public StringBuffer(int capacity):指定容量的字符串缓冲区对象
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法：
public int capacity()：返回当前容量。 理论值(不掌握)
public int length():返回长度（字符数）。 实际值
C:案例演示
构造方法和长度方法的使用
package com.heima.stringbuffer;
public class Demo1_StringBuffer {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
System.out.println(sb.length()); //容器中的字符个数,实际值
System.out.println(sb.capacity()); //容器的初始容量,理论值
StringBuffer sb2 = new StringBuffer(10);
System.out.println(sb2.length());
System.out.println(sb2.capacity());
StringBuffer sb3 = new StringBuffer("heima");
System.out.println(sb3.length()); //实际字符的个数
System.out.println(sb3.capacity()); //字符串的length + 初始容量
}
}13.03_常见对象(StringBuffer的添加功能)
A:StringBuffer的添加功能public StringBuffer append(String str):
可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):
在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
package com.heima.stringbuffer;
public class Demo2_StringBuffer {
public static void main(String[] args) {
demo1();
StringBuffer sb = new StringBuffer("1234");
sb.insert(3, "heima"); //在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常
System.out.println(sb);
}
private static void demo1() {
StringBuffer sb = new StringBuffer();
StringBuffer sb2 = sb.append(true);
StringBuffer sb3 = sb.append("heima");
StringBuffer sb4 = sb.append(100);
System.out.println(sb.toString()); //StringBuffer类中重写了toString方法,显示的是对象中的属性值
System.out.println(sb2.toString());
System.out.println(sb3.toString());
System.out.println(sb4.toString());
}
}13.04_常见对象(StringBuffer的删除功能)
A:StringBuffer的删除功能public StringBuffer deleteCharAt(int index):
删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):
删除从指定位置开始指定位置结束的内容，并返回本身
13.05_常见对象(StringBuffer的替换和反转功能)
A:StringBuffer的替换功能public StringBuffer replace(int start,int end,String str):
从start开始到end用str替换
B:StringBuffer的反转功能
public StringBuffer reverse():
字符串反转
13.06_常见对象(StringBuffer的截取功能及注意事项)
A:StringBuffer的截取功能public String substring(int start):
从指定位置截取到末尾
public String substring(int start,int end):
截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
B:注意事项
注意:返回值类型不再是StringBuffer本身
13.07_常见对象(StringBuffer和String的相互转换)
A:String – StringBuffera:通过构造方法
b:通过append()方法
B:StringBuffer – String
a:通过构造方法
b:通过toString()方法
c:通过subString(0,length);
package com.heima.stringbuffer;
public class Demo6_StringBuffer {
public static void main(String[] args) {
//demo1();
StringBuffer sb = new StringBuffer("heima");
String s1 = new String(sb); //通过构造将StringBuffer转换为String
System.out.println(s1);
String s2 = sb.toString(); //通过toString方法将StringBuffer转换为String
System.out.println(s2);
String s3 = sb.substring(0, sb.length()); //通过截取子字符串将StringBuffer转换为String
System.out.println(s3);
}
private static void demo1() {
StringBuffer sb1 = new StringBuffer("heima"); //通过构造方法将字符串转换为StringBuffer对象
System.out.println(sb1);
StringBuffer sb2 = new StringBuffer();
sb2.append("heima"); //通过append方法将字符串转换为StringBuffer对象
System.out.println(sb2);
}
}13.08_常见对象(把数组转成字符串)
A:案例演示需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1,2,3};
输出结果：
"[1, 2, 3]"
用StringBuffer的功能实现package com.heima.test;
public class Test1 {
/**
* * 需求：把数组中的数据按照指定个格式拼接成一个字符串
*
举例： int[] arr = {1,2,3}; 输出结果： "[1, 2, 3]" 用StringBuffer的功能实现*/
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arrayToString(arr));
}
/*
* 将数组转换为字符串
* 1,返回值类型String
* 2,参数列表int[]
*
* arrayToString 将数组转换为字符串
* array2String 2与to的发音一样就用2替换了to,后来演变成了一种书写习惯
* dom4j domForJ
*/
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();
}
}
13.09_常见对象(字符串反转)
A:案例演示需求：把字符串反转 举例：键盘录入"abc" 输出结果："cba" 用StringBuffer的功能实现
package com.heima.test;
import java.util.Scanner;
public class Test2 {
/**
* * A:案例演示
*
需求：把字符串反转 举例：键盘录入"abc" 输出结果："cba" 用StringBuffer的功能实现*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //创建键盘录入对象
String line = sc.nextLine(); //将键盘录入的字符串存储在line中
/*StringBuffer sb = new StringBuffer(line); //将字符串转换为StringBuffer对象
sb.reverse(); //将缓冲区的内容反转
System.out.println(sb.toString());*/
System.out.println(revString(line));
}
/*
* 将字符串反转
* 1,返回值类型String
* 2,参数列表String line
*/
public static String revString(String line) {
StringBuffer sb = new StringBuffer(line); //将字符串转换为StringBuffer对象
sb.reverse(); //将缓冲区的内容反转
return sb.toString();
}
}
13.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是可变的字符序列
13.11_常见对象(String和StringBuffer分别作为参数传递)
A:形式参数问题String作为参数传递
StringBuffer作为参数传递
B:案例演示
String和StringBuffer分别作为参数传递问题
package com.heima.stringbuffer;
public class Demo7_StringBuffer {
/**
* * A:形式参数问题
* String作为参数传递
* StringBuffer作为参数传递
* B:案例演示
* String和StringBuffer分别作为参数传递问题
*
基本数据类型的值传递,不改变其值
引用数据类型的值传递,改变其值
String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
*/
public static void main(String[] args) {
String s = "heima";
System.out.println(s);
change(s);
System.out.println(s);
System.out.println("---------------------");
StringBuffer sb = new StringBuffer();
sb.append("heima");
System.out.println(sb);
change(sb);
System.out.println(sb);
}
public static void change(StringBuffer sb) {
sb.append("itcast");
}
public static void change(String s) {
s += "itcast";
}
}13.12_常见对象(数组高级冒泡排序原理图解)
A:画图演示需求：
数组元素：{24, 69, 80, 57, 13}
请对数组元素进行排序。
冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
13.13_常见对象(数组高级冒泡排序代码实现)
A:案例演示数组高级冒泡排序代码
package com.heima.array;
public class Demo1_Array {
/**
* * A:案例演示
* 数组高级冒泡排序代码
*/
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
bubbleSort(arr);
//selectSort(arr);
print(arr);
}
/*
* 冒泡排序
* 1,返回值类型,void
* 2,参数列表,int[] 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次
*/
public static 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]) {
/*int temp = arr[j];
arr[j] = arr[j + 1];
arr[j+1] = temp;*/
swap(arr,j,j+1);
}
}
}
}
/*
* 打印数组
* 1,返回值类型void
* 2,参数列表int[]arr
*/
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}13.14_常见对象(数组高级选择排序原理图解)
A:画图演示需求：
数组元素：{24, 69, 80, 57, 13}
请对数组元素进行排序。
选择排序
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
13.15_常见对象(数组高级选择排序代码实现)
A:案例演示数组高级选择排序代码
13.16_常见对象(数组高级二分查找原理图解)
A:画图演示二分查找
前提：数组元素有序
13.17_常见对象(数组高级二分查找代码实现及注意事项)
A:案例演示数组高级二分查找代码
B:注意事项
如果数组无序，就不能使用二分查找。
因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。
package com.heima.array;
public class Demo2_Array {
/**
* * A:案例演示
* 数组高级二分查找代码
* B:注意事项
* 如果数组无序，就不能使用二分查找。
* 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。
*/
public static 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,int value
*/
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) { //当中间值小于了要找的值
min = mid + 1; //最小的索引改变
}else if (arr[mid] > value){ //当中间值大于了要找的值
max = mid - 1; //最大的索引改变
}
mid = (min + max) / 2; //无论最大还是最小改变,中间索引都会随之改变
if(min > max) { //如果最小索引大于了最大索引,就没有查找的可能性了
return -1; //返回-1
}
}
return mid;
}
}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)
public static void main(String[] args) {
int[] arr = {33,22,11,44,66,55};
System.out.println(Arrays.toString(arr)); //数组转字符串
Arrays.sort(arr); //排序
System.out.println(Arrays.toString(arr));
int[] arr2 = {11,22,33,44,55,66};
System.out.println(Arrays.binarySearch(arr2, 22));
System.out.println(Arrays.binarySearch(arr2, 66));
System.out.println(Arrays.binarySearch(arr2, 9)); //-插入点-1
}13.19_常见对象(基本类型包装类的概述)
A:为什么会有基本类型包装类将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
B:常用操作
常用的操作之一：用于基本数据类型与字符串之间的转换。
C:基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
13.20_常见对象(Integer类的概述和构造方法)
A:Integer类概述通过JDK提供的API，查看Integer类的说明
Integer 类在对象中包装了一个基本类型 int 的值,
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
public Integer(int value)
public Integer(String s)
C:案例演示
使用构造方法创建对象
13.21_常见对象(String和int类型的相互转换)
A:int – Stringa:和”“进行拼接
b:public static String valueOf(int i)
c:int – Integer – String(Integer类的toString方法())
d:public static String toString(int i)(Integer类的静态方法)
B:String – int
a:String – Integer – int
public static int parseInt(String s)
package com.heima.wrapclass;
public class Demo3_Integer {
/**
* * A:int -- String
* a:和""进行拼接
* b:public static String valueOf(int i)
* c:int -- Integer -- String(Integer类的toString方法())
* d:public static String toString(int i)(Integer类的静态方法)
* B:String -- int
* a:String -- Integer -- int
* public static int parseInt(String s)
基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型
*/
public static void main(String[] args) {
//demo1();
String s1 = "true";
boolean b = Boolean.parseBoolean(s1);
System.out.println(b);
//String s2 = "abc";
//char c = Character.p //char的包装类Character中没有pareseXxx的方法
//字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
}
private static void demo1() {
//int ----> String int转换成String
int i = 100;
String s1 = i + ""; //推荐用
String s2 = String.valueOf(i); //推荐用
Integer i2 = new Integer(i);
String s3 = i2.toString();
String s4 = Integer.toString(i);
System.out.println(s1);
//String----> int String 转换int
String s = "200";
Integer i3 = new Integer(s);
int i4 = i3.intValue(); //将Integer转换成了int数
int i5 = Integer.parseInt(s); //将String转换为int,推荐用这种
}
}13.22_常见对象(JDK5的新特性自动装箱和拆箱)
A:JDK5的新特性自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
B:案例演示
JDK5的新特性自动装箱和拆箱
Integer ii = 100;
ii += 200;
C:注意事项
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。
public static void main(String[] args) {
// int x = 100;
// Integer i1 = new Integer(x); //将基本数据类型包装成对象,装箱
//
// int y = i1.intValue(); //将对象转换为基本数据类型,拆箱
Integer i2 = 100; //自动装箱,把基本数据类型转换成对象
int z = i2 + 200; //自动拆箱,把对象转换为基本数据类型
System.out.println(z);
Integer i3 = null;
int a = i3 + 100; //底层用i3调用intValue,但是i3是null,null调用方法就会出现
System.out.println(a); //空指针异常java.lang.NullPointerException
}13.23_常见对象(Integer的面试题)
A:Integer的面试题看程序写结果
package com.heima.wrapclass;
public class Demo5_Integer {
/**
* @param args
*/
public static void main(String[] args) {
Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2); //false
System.out.println(i1.equals(i2)); //true
System.out.println("-----------");
Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4); //false
System.out.println(i3.equals(i4)); //true
System.out.println("-----------");
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6); //true
System.out.println(i5.equals(i6)); //true
System.out.println("-----------");
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8)); //true
/*
* -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
* 如果超过了byte取值范围就会再新创建对象
*
* public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high) //i>= -128 && i <= 127
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
*/
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Java基础13-总结StringBuffer,StringBuilder,数组高级，Arrays，Integer，Character
- 常见对象_StringBuffer、数组高级以及Arrays、Integer、Character总结
- 常见对象StringBuffer、Arrays类和基本类型包装类+JAVA学习笔记-DAY13
- Java基础13-总结StringBuffer,StringBuilder,数组高级，Arrays，Integer，Character
- JavaSE实战——API(上) Eclipse使用、Object、Scanner、String、StringBuffer、StringBuilder、Integer、模拟用户登录案例
- JAVA基础：String, StringBuffer, StringBuilder ——区别，用法及常见问题
- StringBuffer,StringBuilder,数组常见操作,Arrays,基本类型包装类--1
- java语言基础(55)——StringBuffer、StringBuilder对象的使用
- 2017 - 10 -19 常见对象 StringBuffer Arrays Integer Character
- JAVA基础学习day13--String、StringBuilder与StringBuffer与包装类
- Java基础——String、StringBuffer、StringBuilder、Integer
- stringBuffer、StringBuilder、排序、Arrays、Jdk1.5新特性(java基础知识十三)
- JAVASE基础-day12（常见对象（Scanner，String））
- JAVASE基础-day14（常见对象（正则，Math..））
- 黑马程序员----【javaSE基础】个人总结--String 、 StringBuffer 和 StringBuilder
- java基础教程：常用对象之StringBuilder StringBuffer（22）
- JAVASE基础-day11（开发工具&常见对象）
- StringBuffer,StringBuilder,数组常见操作,Arrays,基本类型包装类--2
- 黑马程序员_Java语言_常见对象(StringBuffer,数组,Arrays)
- Java基础学习笔记13——（StringBuffer的使用，数组高级，Arrays工具类，Integer和Character等包装类）