DAY11

DAY11

回顾内容

1:常用类

Object类中的方法:

Public  Class getClass():返回当前正在运行的那个类:class  包名.类名

hashCode():底层是根据哈希表(哈希算法)算出来的,理解为地址值

public  String toString():就用来构造一个字符串(将某个对象):建议所有子类都重写该方法

如果直接输出对象名称和使用对象名直接调用toString():结果一样:

全路径名称:包名.类名

clone():要使用该方法,那么当前对象所在的那个类一定要实现cloneable接口,重写Object类中clone()方法,才能去复制对象!

finalize(),final,finally的区别:

finalize():和垃圾回收器有关系,当前一个对象没有更多引用的时候,垃圾回收器会回收这个对象(垃圾回收器所在的线程:垃圾回收线程,具有随机性!)

equals()方法:默认比较的是地址值,重写了Object类中的equals()方法,就会比较是两个对象的内容是否相同!

2 Scanner类

这个类中会提供一些方法:

hasNextXXX():判断功能,判断是否有下一个可以接收的XXX类型的元素

nextXXX():如果有这样XXX的元素,那么就获取         

使用键盘录入int类型的和字符串类型的数据,如果先录入int类型的数据,在录入String类型的数据,String类型的数据漏掉了(回车符号的问题:)在去录入字符串的时候1)重新创建一个Scanner对象,2)使用next()

集合中的迭代器遍历集合中的元素:

Iterator iterator()

Iterator:接口中有两个方法:

Public boolean hasNext();判断是否有下一个可以迭代的元素

Object next();如果集合中有下一个可以迭代的,就获取这个元素

 

3 String类

定义一个字符串:

String str = new String(“hello”);

或者String str =“hello” ;

String类的特点:它是不可变的字符序列,线程角度考虑:线程安全,效率是最低的,

每次拿字符串常量赋值,都会在字符串常量池中开辟空间(没有这个值的话),耗费空间

StringBuffer:它是一个不可变的字符序列.,构造字符串缓冲区(容器类型)

StringBulider:和StringBuffer有着兼容的API

编码和解码的问题:(两个需要保持编码一致)

将String----->byte[]:编码public byte[] getBytes(charsetName  ch):指定一种编码格式

平台默认的编码格式:GBK

public  byte[] getBytes() ;

将byte[]-------->String解码:     String ss = String(byte[] bys,charsetName ch):平台编码集GBK

String ss = String(byte[] bys):使用默认的GBK的编码格式

String的常用的方法:

length():获取字符串长度

tocharArray():将字符串转换成字符数组

substring(int begin):从指定位置开始截取,默认截取到末尾,返回一个新的 字符串

substring(int begin,int end):从指定位置开始截取,到指定位置结束,包前不包后(返回一个新的字符串)

toLowerCase():把字符串转换成小写

toUpperCase():把字符串转换成大写

valueOf方法可以将任何的数据类型转换成字符串包括对象

valueOf(int i)

valueOf(char[] chs):

valueOf(Object obj);

 

 一  String类中的其他功能:

1替换功能:

public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换

public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新的字符串去替代

去除字符串两端空格:

public String trim()

两个字符串进行比较:

public int compareTo(String anotherString)  是Comparable接口中的方法(该接口可以实现一个自然排序)

Comparator接口可以比较器排序

public class StringDemo {

public static void main(String[] args) {

//定义字符串

String s1 = "helloworld" ;

//替换功能

public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换

String s2 = s1.replace('l', 'k') ;

/System.out.println("s:"+s2);

//public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代

String s3 = s1.replaceAll("owo", "ak47") ;

System.out.println("s3:"+s3);

String s4 = " hello world " ;

System.out.println("s4:"+"----"+s4+"----");

//public String trim()

String s5 = s4.trim() ;

System.out.println("s5:"+"----"+s5+"----")

//public int compareTo(String anotherString)

String s6 = "hello" ;

String s7 = "hello" ;

String s8 = "abc" ;

System.out.println("compareTo():"+s6.compareTo(s7));

System.out.println("compareTo():"+s6.compareTo(s8));

}

}

2  compareTo

String a="a",b="b";

System.out.println(a.compareto.b);

则输出-1；

若a="a",b="a"则输出0；

若a="b",b="a"则输出1；

单个字符这样比较，若字符串比较长呢？？

若a="ab",b="b",则输出-1；

若a="abcdef",b="b"则输出-1；

也是说，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值

如果首字母相同呢？？

若a="ab",b="a",输出1；

若a="abcdef",b="a"输出5；

若a="abcdef",b="abc"输出3；

若a="abcdef",b="ace"输出-1；

即参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值，如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值

//在底层代码中,一个字符串会自动会转换成字符数组

 private final char value[];

//s1= "helloworld" ;

//s2= "hel" ;

/将s1和s2的字符串自动转换成了字符数组

//s1:'h','e','l','l','0'

//s2:'h','e','l'

  public int compareTo(String anotherString) {anotherString==>s2="hel"

        int len1 = value.length; //s1.length=5

        int len2 = anotherString.value.length;// s2.length: = 3

        int lim = Math.min(len1, len2);// Math.min(5,3) ;=====>int lim = 3 ;

        char v1[] = value;//'h','e','l','l','0'

        char v2[] = anotherString.value;//"hel"

        int k = 0;

        while (k < lim) {k< lim=3

            char c1 = v1[k];// char c1 = 'h','e','l','l','0' = v1[k] = 'h'

            char c2 = v2[k];//char c2 = 'h','e','l' = v2[k] = 'h'

            if (c1 != c2) {

                return c1 - c2;

            }

            k++;

        }

        return len1 - len2; // len1 - len2 = s1.length() - s2.lenth() = 5 -3 = 2

    }

练习:需求:键盘录入一个字符串,将字符串进行反转

 1举例:

 "abc"--->"cba"

  分析:

 1)创建键盘录入对象,录入并接收一个字符串

 2)定义空字符串

 3)可以将字符串转换成字符数组:toCharArray();

 4)遍历字符数组,倒着遍历

 5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接

 6)输出即可

public class StringTest3 {

public static void main(String[] args) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in) ;

//录入数据并接收数据

System.out.println("请您输入一个字符串:");

String line = sc.nextLine() ;

//定义一个空字符串

String result = "" ;

//将字符串转换成字符数组

char[] chs = line.toCharArray() ;

//遍历字符数组,倒着遍历

for(int x = chs.length-1; x >=0 ; x --){

//获取到每一个字符

result+= chs[x] ;

}

String result = myReverse(line) ;

//输出

System.out.println("result:"+result);

}

//写一个功能实现

public static String myReverse(String s){

//定义空字符串

String result = "" ;

//将字符串字符数组

char[] chs = s.toCharArray() ;

//遍历字符数组

for(int x = chs.length -1 ; x >=0; x --){

//拼接每一个字符

result+= chs[x];

}

return result ;

}

}

3 Stringbuffer

线程(多线程中讲)

线程安全---->同步---->执行效率低!

举例:银行的网站,医院的平台

线程不安全--->不同步--->执行效率高

举例:一些论坛网站,相亲网站..

在是开发中,线程不安全可能会造成死锁的现象线程安全和执行效率是相对的,并且也是困扰开发者的因素

StringBuffer:线程安全的可变字符序列

面试题:

StringBuffer和String的区别?

StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代

StringBuffer:线程不安全,单线程单纯为了提供执行效率)

String:普通的一个字符串,从内存角度考虑,耗费空间

StringBuffer的构造方法:

public StringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为16 个字符

public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区

public StringBuffer(String str)

构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16加上字符串参数的长度。

常用的功能:

public int length():获取字符串长度数

public int capacity():获取当前字符串缓冲区的容量

public class StringBufferDemo {

public static void main(String[] args)

StringBuffersb = "hello" ;

String s = "hello" ;

    StringBuffersb = s ;

public StringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为16 个字符

//创建一个字符串缓冲区对象

StringBuffer sb = new StringBuffer() ;

System.out.println("sb.length:"+sb.length());

System.out.println("sb.capacity:"+sb.capacity());//16

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

//public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区

StringBuffer sb2 = new StringBuffer(50) ;

System.out.println("sb2.length:"+sb2.length());

System.out.println("sb2.capacity:"+sb2.capacity());//50

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

StringBuffer sb3 = new StringBuffer("hello") ;

System.out.println("sb3.length:"+sb3.length());

System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度

}

}

2 StringBuffer中的和添加有关的方法

public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)

public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

public class StringBufferDemo2 {

public static void main(String[] args) {

//创建一个字符串缓冲区对象

StringBuffer sb = new StringBuffer() ;

//追加数据

sb.append("hello") ;

sb.append(true) ;

sb.append(13.45) ;

sb.append('A') ;

sb.append(12.56F);*/

//链式编程sb.append("hello").append(true).append(13.45).append('A').append(12.56F);

//public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

sb.insert(5, "world") ;

//输出

System.out.println("sb:"+sb);

}

}

3 StringBuffer的反转功能:

public StringBuffer reverse():将此字符串中的字符序列直接反转

public class StringBufferDemo4 {

public static void main(String[] args) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in) ;

//录入并接收数据

System.out.println("请您输入一个字符串:");

String line = sc.nextLine() ;

//可以创建字符串缓冲区对象

StringBuffer sb = new StringBuffer(line) ;

//public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String

//反转功能

 String result = sb.reverse().toString() ;

 System.out.println("result:"+result);

}

}

4 StringBuffer的替换功能:

public StringBuffer replace(int start, int end,String str)

从指定位置开始到指定位置结束的字符用str子字符串去替代

public class StringBufferDemo5 {

public static void main(String[] args) {

//创建字符串缓冲区对象

StringBuffer sb = new StringBuffer() ;

//给缓冲添加数据

sb.append("hello") ;

sb.append("world") ;

sb.append("java") ;

//public StringBuffer replace(int start, int end,String str)

sb.replace(5, 10, "节日快乐") ;

System.out.println("sb:"+sb);

}

}

5 StringBuffer的截取功能:

 *public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串

public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

6  

String,StringBuffer,StringBuilder的区别?

String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)

从线程角度考虑:

StringBuilder线程不安全,不同步,执行效率高它比StringBuffer要快

string和StringBuffer作为形式参数

String类型作为形式参数和基本数据类型作为形式参数的效果一样

public class StringBufferDemo2 {

public static void main(String[] args) {

//定义两个字符串

String s1 = "hello" ;

String s2 = "world" ;

System.out.println(s1+"---"+s2);//hello---world

change(s1,s2) ;

System.out.println(s1+"---"+s2);//hello---world

//定义两个字符串缓冲区对象

StringBuffer sb1 = new StringBuffer("hello") ;

StringBuffer sb2 = new StringBuffer("world") ;

System.out.println(sb1+"---"+sb2);//hello---world

change(sb1,sb2);

System.out.println(sb1+"---"+sb2);//hello---worldworld

//缓冲区是不变

}

public static void change(StringBuffer sb1 ,StringBuffer sb2){

sb1 = sb2 ;  //缓冲区不变"world"

sb2.append(sb1) ;//worldworld

}

public static void change(String s1,String s2){

s1 = s2 ;

s2 = s1 + s2 ;

}

}

7 类与类之间的转换

 A类型--->B类型

这里面可能最终使用B类型里面的功能

B类型--->A类型

有时候需要的不是B类型,所以又要将B类型-->A类型

StringBuffer--->String之间的相互转换

两个共同特点:都属于容器类型的变量

数组:只能存储同一种数据类型的元素,数组的长度是固定的

int[] arr = {10,20,40,50,"hello"}  错误的

StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串

三 Integer

需求:求一个整数100对应的二进制,八进制,十六进制

需求:要求出Integer类型范围:

java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...

对于每个基本数据类型都会被自动封装成一个引用类型

基本类型引用类型

intInteger

charCharacter

byteByte

booleanBoolean

doubleDouble

floatFloat

longLong

shortShort

 

public class IntegerDemo {

public static void main(String[] args) {

//public static String toBinaryString(int i)

System.out.println(Integer.toBinaryString(100)) ;

//public static String toOctalString(int i)

System.out.println(Integer.toOctalString(100));

//public static String toHexString(int i)

System.out.println(Integer.toHexString(100));

//public static final int MAX_VALUE

//public static final int MIN_VALUE

System.out.println(Integer.MAX_VALUE);//2147483647

System.out.println(Integer.MIN_VALUE);//-2147483647

}

}

2 Integer类的构造方式:

public Integer(int value):将一个int类型的数据封装成一个引用类型

public Integer(String s):将一个字符数类型封装成一个Integer类型

注意事项:

该字符串必须是数字字符串否则:java.lang.NumberFormatException

public class IntegerDemo2 {

public static void main(String[] args) {

public Integer(int value)

//创建一个Integer对象

Integer i = new Integer(100);

//Integer i = 100 ;//jdk5以后的自动装箱!

System.out.println("i:"+i);

//public Integer(String s)

String s = "20" ;

Integer ii = new Integer(s) ;

System.out.println("s:"+s);

}

}

 

3 int类型和String类型的相互转换

public class IntegerTest {

Public static void main(String[] args) {

//定义一个int类型的数据

int number = 100 ;

//方式1)字符串拼接符

String s1 = "" + number ;

System.out.println("s1:"+s1);

//方式2:int--->Integer类型

Integer i = new Integer(number) ;

//Integer--->String

//public String toString()

String s2 = i.toString() ;

System.out.println("s2:"+s2);

//方式3)public static String toString(int i)

String s3 = Integer.toString(number) ;

System.out.println("s3:"+s3);

//方式4)

//public static Integer valueOf(int i)

Integer integer= Integer.valueOf(number) ;

String s4 = integer.toString() ;

System.out.println("s4:"+s4);

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

//定义一个字符串:

String s = "10" ;

//方式1:String--->Integer---->int

Integer ii = new Integer(s) ;

//public int intValue()以int 类型返回该Integer 的值

int num = ii.intValue() ;

System.out.println("num:"+num);

//public static int parseInt(String s)

int num2 = Integer.parseInt(s) ;

System.out.println("num2:"+num2);

//Integer的内存缓存区:IntegerCashe

//low = -128

//high=127

Integer i1 = 127 ;//----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;

Integer i2 = 127 ;

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

Integer i3 = 128 ;

Integer i4 = 128 ;

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

 

}

}

四 Character:

 Character类在对象中包装一个基本类型 char的值。Character类型的对象包含类型为 char的单个字段

构造方法:

public Character(char value)构造一个新分配的Character 对象，用以表示指定的char 值。

public class CharacterDemo {

public static void main(String[] args) {

//创建一个Character类的对象

//Character character = new Character((char)97) ;

Character character = new Character('a') ;

System.out.println("character:"+character);

}

}

 2 Character类的判断功能:

public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。

 public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母

public static boolean isDigit(char ch)确定指定字符是否为数字。

Character常用的转换功能:

 public static char toUpperCase(char ch):将指定字符转换成大写

public static char toLowerCase(char ch):将指定字符转换成小写

  练习需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成

public class CharacterDemo2 {

public static void main(String[] args)

//public static boolean isLowerCase(char ch)确定指定字符是否为小字母

System.out.println("isLowerCase:"+Character.isLowerCase('a'));

System.out.println("isLowerCase:"+Character.isLowerCase('A'));

System.out.println("isLowerCase:"+Character.isLowerCase('0'));

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

//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母

System.out.println("isUpperCase:"+Character.isUpperCase('a'));

System.out.println("isUpperCase:"+Character.isUpperCase('A'));

System.out.println("isUpperCase:"+Character.isUpperCase('0'));

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

//public static boolean isDigit(char ch)确定指定字符是否为数字。

System.out.println("isDigit:"+Character.isDigit('a'));

System.out.println("isDigit:"+Character.isDigit('A'));

System.out.println("isDigit:"+Character.isDigit('0'));

}

}

五冒泡排序:

冒泡排序的思想:

两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....

public class ArrayTest {

public static void main(String[] args) {

//定义一个数组,静态初始化

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

System.out.println("排序前:");

//遍历数组

printArray(arr) ;

/*//第一次比较

//arr.length-1:为了防止角标越剧

//arr.length-1-0:为了减少比较的次数

for(int x = 0 ; x < arr.length-1-0;x++){

//判断:两两比较,大的往后方法

if(arr[x]>arr[x+1]){

//中间变量进行互换

int temp = arr[x] ;

arr[x] = arr[x+1] ;

arr[x+1] = temp;

}

}

System.out.println("第一次比较后:");

printArray(arr) ;

//第二次比较:

for(int x = 0 ; x < arr.length-1-1; x ++){

if(arr[x]>arr[x+1]){

int temp = arr[x] ;

arr[x] = arr[x+1] ;

arr[x+1] =temp ;

}

}

System.out.println("第二次比较后:");

printArray(arr) ;

//第三次比较:

//arr.length-1:为了防止角标越界

////arr.length-1-2:为了减少比较的次数

for(int x = 0 ; x < arr.length-1-2; x ++){

if(arr[x]>arr[x+1]){

int temp = arr[x] ;

arr[x] = arr[x+1] ;

arr[x+1] =temp ;

}

}

System.out.println("第三次比较后:");

printArray(arr) ;

//第三次比较:

//arr.length-1:为了防止角标越界

////arr.length-1-3:为了减少比较的次数

for(int x = 0 ; x < arr.length-1-3; x ++){

if(arr[x]>arr[x+1]){

int temp = arr[x] ;

arr[x] = arr[x+1] ;

arr[x+1] =temp ;

}

}

System.out.println("第四次比较后:");

printArray(arr) ;*/

/**

 *上述代码重复度高,所以改进

 */

/*for(int x = 0 ; x <4 ; x ++){

for(int y = 0 ; y < arr.length-1-x ; y++){

//判断

if(arr[y]>arr[y+1]){

int temp = arr[y] ;

arr[y] = arr[y+1] ;

arr[y+1] = temp ;

}

}

}

System.out.println("排序后:");

printArray(arr) ;*/

/**

 *上述代码不够好,如果数组非常多,那么如何进行操作,应该定义一个功能,当前比较的次数是一个数组长度-1次

 */

bubbleSort(arr) ;

System.out.println("排序后:");

printArray(arr) ;

}

//冒泡排序的代码

//最终版代码

public static void bubbleSort(int[] arr){

for(int x = 0 ; x < arr.length-1; x ++){

for(int y = 0 ; y < arr.length-1-x ; y++){

//判断

if(arr[y]>arr[y+1]){

int temp = arr[y] ;

arr[y] = arr[y+1] ;

arr[y+1] = temp ;

}

}

}

}

//遍历数组的功能:[元素1,元素2,....]

public static void printArray(int[] arr){

System.out.print("[");

//遍历数组

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

//判断是否是最大索引

if(x==arr.length-1){

System.out.println(arr[x]+"]");

}else{

System.out.print(arr[x]+", ");

}

}

}

}