java总结1028/1029

A:  Object类:
Object类是所有类的父类,是类层次结构的根类,所有对象都实现这个类里的方法(包括数组)
Object类中的方法:
1.public int hashCode()     返回该对象的哈希码值
通过哈希算法(哈希表hashable)---->地址值(并不是真正的地址值)
Student s1 = new Student() ;
System.out.println(s1.hashCode());//1460821906
2.public final Class getClass()    返回此 Object 的运行时类  (Java反射机制中讲!)

Class类(不是class 区分大小写)中的一个方法
public String getName()以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
返回全路径名称:
Class c1 = s1.getClass() ;
String name = c1.getName() ;
System.out.println("name:"+name);//org.westos.object_01.Student :全路径名称
//org.westos.object_01.Student
3.public String toString();返回该对象的字符串表示(建议所有子类都重写此方法)
如果直接输出对象名称,想要显示当前对象的成员变量的值,那么必须重写Object类中的toString()方法

4.public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。
==和equal()方法的区别
==:比较的是两个对象的地址值是否相同,
equals()方法默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同

5.protected void finalize()throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法,
但是,什么时候调用垃圾回收器不确定;

System类中的一个方法:
public void gc():运行垃圾回收器,这个垃圾回收器最终调用的就是finalize()方法

6.protected Object clone()创建并返回此对象的一个副本
                throws CloneNotSupportedException
                
注意事项:
Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。

//重写Object类中clone()
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
//没有讲clone方法之前:
Student s3 = s1; //把s1地址值赋值s3对象,s3指向s1的堆内存中的地址值


B:  Scanner类:
Scanner:用来创建一个文本扫描器(键盘录入)
java.util.Scanner
Scanner sc = new Sacnner(System.in);
ava高级特性:IO流(后面讲)
BufferReder:字符缓冲流来键盘录入

System类中的静态字段:
public static final InputStream in:  标准输入流
InputStream :字节流InputStream is = System.in ;  实质:抽象类多态
public static final OutputStream out:  标准输出流
 
开发步骤:
1)创建键盘录入对象
2)录入数据
3)输出

Scanner类中常用的方法:
  判断的功能:
  细节:可以添加逻辑判断
  hasNextXXX(); 在录入数据之前,加上判断功能,判断是否有下一个可以录入的XXX类型的数据
  nextXXX();//通过录入获取这个int类型的数据
  
举例:
  public boolean hasNextInt()
nextInt(); 
nextInt():录入int类型的数据
nextLine():录入一个字符串类型
java.util.InputMismatchException:输入和想到的数据不匹配
Scanner类中的注意事项:
  先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接收数据
回车换行符导致的!
  解决方案:
  在第二次录入String类型数据之前,需要重新创建键盘录入对象录入String类型


C:  String类:
1.String类:
  代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变
  
String类常用的构造方
法:
  String():表示一个空字符序列。
  public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
  public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
  public String(char[] value):将字符数组构造成一个字符串
  public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
  public String(String original):通过字符串常量构造一个字符串对象

获取字符串的长度功能:
  public int length()
面试题:
  数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?
  数组没有length(),length属性
  字符串中有length()
集合中没有length(),获取集合中元素数量:size()

编码和解码:一定要保证编码格式一致
  编码:
  把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)
  解码:
  把当前的byte[]转成能看懂的东西(String):byte[]----->String  :public String(byte[] bytes,CharsetName ch)

字符串的一个特点:一旦被赋值,其值不能被改变(不可变的字符序列)
String类型作为形式参数和基本数据类型的效果一样
  
面试题:
String s = "hello"
和String s = new String("hello") 两个有什么区别?分别创建了几个对象
 
第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))


2.看程序写结果:
 @author Apple
 
public class StringDemo2 {

public static void main(String[] args) {
//创建字符串对象
String s1 = new String("hello") ;
String s2 = new String("hello") ;

System.out.println(s1==s2);//false

String s3 = "hello" ;
String s4 = "hello" ;
System.out.println(s3==s4); 
System.out.println(s3.equals(s4));

String s5 = new String("world") ;
String s6 = "world" ;
System.out.println(s5==s6);
System.out.println(s5.equals(s6));
}
}

结果: false true true false true

3.看程序,写结果
字符串变量相加,先开辟空间,在相加
字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!
  @author Apple
 
public class StringDemo2 {

public static void main(String[] args) {
String s1 = "hello";  
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false
//System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString());
// s1+s2 ====>new String("helloworld")
System.out.println(s3.equals((s1 + s2)));//true , 


System.out.println(s3 == "hello" + "world");//true
System.out.println(s3.equals("hello" + "world"));//true

/**
* 通过反编译工具查看第三个输出语句:
* System.out.println(s3 == "helloworld");
System.out.println(s3.equals("helloworld"));
* */
}
}

4.String类的中常用的判断功能:
boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
boolean contains(String str):判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str):是否以str子字符串开头
boolean endsWith(String str):判断是否以str子字符串结尾
boolean isEmpty():判断字符串是否为空

String s = "" ;空字符
String s = " " ;字符串"空格"
String s = null ;当前字符串对象为空

5.String类的获取功能:
  int length():获取字符串长度功能
char charAt(int index):返回的是索引处对应的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
为什么这里的字符用int来定义:97 'a'
int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索

String substring(int start):从指定位置开始截取字符串,默认截取到末尾
String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)

6.String类的转换功能(重点)
byte[] getBytes():将字符串转换字节数组
char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs):将字符数组转换成字符串
static String valueOf(int i):将一个int类型的数据转换成字符串
注意:
String类中的valueOf()可以将任何数据类型转换成字符串
String toLowerCase():将字符串全部转成小写
String toUpperCase():将字符串全部转换成大写
String concat(String str):字符串拼接方法

7.方法嵌套
 Math.max(Math.max(a,b),c);
 方法递归:方法调用本身的一种现象
三个条件:
1)需要定义个方法
2)方法必须有出口条件
3)必须有某一种规律
   public void show(int n){
 
if(n<0){
  System.exit(0) ; //让jvm退出,程序结束
  }
 
  System.out.println(n) ;
  show(--n) ;

8. String类中的其他功能:
替换功能:
public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
去除字符串两端(中间的不管)空格:
public String trim()
两个字符串进行比较:
public int compareTo(String anotherString)  是Comparable接口中的方法(该接口可以实现一个自然排序)
 Comparator接口可以比较器排序
在API源码中，String的compareTo其实就是一次比较两个字符串的ASCII码。
如果两个字符串的ASCII相等则继续后续比较，否则直接返回两个ASCII的差值。
如果两个字符串完全一样，则返回0.
9.面试题:
class B{
public B(){
array = new ArrayList<String>() ;
}

//成员变量的位置
public static B t1 = new B() ;
public static B t2 = new B() ;

{
System.out.println("构造代码块");
}

static{
System.out.println("静态代码块!");
}
}
public class Demo {
public static void main(String[] args) {

B b = new B() ;//构 构 静 构

//静态代码块 ,构造代码块,构造方法的优先级问题:
//静态代码块>构造代码块>构造方法...
}


D: StringBuffer类:
1.StringBuffer:
线程(多线程中讲)
线程安全---->同步---->执行效率低!
举例:
银行的网站,医院的平台
StringBuilder
线程不安全--->不同步--->执行效率高
举例:
一些论坛网站,相亲网站..
在实际开发中,线程不安全可能会造成死锁的现象!
线程安全和执行效率是相对的,并且也是困扰开发者的因素!
 StringBuffer:线程安全的可变字符序列
2.StringBuffer的构造方法:
public StringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
public StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
 
3.常用的功能:
public int length():获取字符串长度数
public int capacity():获取当前字符串缓冲区的容量//默认:初始容量16 + 当前字符串长度

4.StringBuffer中的和添加有关的方法
public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身


5.StringBuffer的删除功能:
public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!


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


7. StringBuffer的替换功能:
public StringBuffer replace(int start, int end,String str)
从指定位置开始到指定位置结束的字符用str子字符串去替代
8. StringBuffer的截取功能:
public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串


9. 面试题:
String,StringBuffer,StringBuilder的区别?

String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!

String和StringBuffer作为形式参数
 
String类型作为形式参数和基本数据类型作为形式参数的效果一样!
public class StringBufferDemo7 {

public static void main(String[] args) {

//定义两个字符串
String s1 = "hello" ;
String s2 = "world" ;
System.out.println(s1+"---"+s2);
change(s1,s2) ;
System.out.println(s1+"---"+s2);

//定义两个字符串缓冲区对象
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 ;
}
}


10. 类与类之间的转换
A类型--->B类型
这里面可能最终使用B类型里面的功能
B类型--->A类型
有时候需要的不是B类型,所以又要将B类型-->A类型
StringBuffer--->String之间的相互转换
//定义一个字符串
String s = "hello" ;
//方式1)使用StringBuffer的构造方式:StringBuffer(String str)
StringBuffer sb = new StringBuffer(s) ;
方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
StringBuffer sb2 = new StringBuffer() ;
sb2.append(s) ;
StringBuffer--->String
//有一个字符串缓冲区对象
StringBuffer buffer = new StringBuffer("world") ;
//1)方式1String的另一种构造方法:String(StringBuffer buffer)
String s2 = new String(buffer) ;
System.out.println("s2:"+s2);
//2)方式2:/public String toString():
//现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
String s3 = buffer.toString() ;
System.out.println("s3:"+s3);
面试题:
StringBuffer和数组的区别?

两个共同特点:都属于容器类型的变量
数组:只能存储同一种数据类型的元素,数组的长度是固定的
int[] arr = {10,20,40,50,"hello"}  错误的
StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串


E:  Integer类: 
1.Integer
需求:求一个整数100对应的二进制,八进制,十六进制
   需求:要求出Integer类型范围:
 
   java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...
 
   对于每个基本数据类型都会被自动封装成一个引用类型
基本类型 引用类型
int Integer
char Character
byte Byte
boolean Boolean
double Double
float Float
long Long
short Short
 
   将基本类型--->引用类型的作用:就是为了和String类型作为转换
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
3.int类型和String类型的相互转换
/定义一个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() ;
//定义一个字符串:
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

F: character类:
1.Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
构造方法:
public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。 

2.Character类的判断功能:
public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
public static boolean isDigit(char ch)确定指定字符是否为数字。


3.Character常用的转换功能:
public static char toUpperCase(char ch):将指定字符转换成大写
public static char toLowerCase(char ch):将指定字符转换成小写

G: 冒泡排序:

冒泡排 序的思想:
两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....

 int[] arr = {13,24,57,69 ,80} ;
 
冒泡排序的代码
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 ;
}
}
}
}