【Java学习笔记】API入门

面向对象三大特征

封装：

类：封装的是对象的属性和行为

方法：封装的是具体的业务逻辑功能实现

访问控制修饰符：封装具体的访问权限，以保护数据的安全

继承：

作用：代码复用

超类：所有派生类所共有的属性和行为

接口：部分派生类所共有的属性和行为

派生类：派生类所特有的属性和行为

特性：单一继承、多接口实现、具有传递性

多态：

行为的多态：所有抽象方法都是多态的（通过方法重写来实现）

对象的多态：所有对象都是多态的（通过向上造型来实现）

最少具备两种状态：自己的形态和object的形态

方式：向上造型、强制类型转换、instanceof判断

String：字符串类型

1、java.lang.String使用final修饰，不能被继承,lang包中不需要import，系统自动引入

2、java中的String在内存中采用Unicode编码方式，任何一个字符都占用两个字节的编码

3、字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值-----不变对象

lang包中String类，有一个private final char value[]，String维护的是一个char的数组

final表示一旦创建，对象不能被改变

字符串底层封装了字符数组，以及针对字符数组的操作算法

String常用方法

无参：

1、length()：获取字符串的长度（字符个数）-----输出int

2、trim()：去除当前字符串两边的空白字符-----输出String

3、toUpperCase()和toLowerCase()：将当前字符串的英文部分转换位全大写/全小写---输出String

有参：所有方法下标默认从0开始，而且下标在内存中是定好的，不能变

4、stratsWith(String str)和endsWith(String str)：判断当前字符串是否以给定的字符串开始/结束的

                                                                             ------输出boolean

5、charAt(int x)：返回当前字符串指定位置上的字符-----输出char

//                      111111
//            0123456789012345
String str = "thinking in java";
char c = str.charAt(5);//5代表下标
System.out.println(c);//输出i

6、indexOf(String str)和lastIndexOf(String str)：检索给定字符串在当前字符串的开始位置/结束位置----输出int

     indexOf(String str,int a)：从下标为a的位置开始找字符串str第一次出现的位置

    若没有检索出给定的字符串，返回结果：-1

//                      111111
//            0123456789012345
String str = "thinking in java";
int index = str.indexOf("in");//检索in在字符串str中的开始位值
System.out.println(a);//2
int index1 = str.indexOf("in",3)//从下标为3的位置开始找in第一次出现的位置

int lastIndex = str.lastIndexOf("in");//找in最后一次出现的位置
System.out.println(lastIndex);//9


int index1 = str.indexOf("IN");//检索IN在字符串str中的开始位置
System.out.println(index1);//当前字符串中不包含IN，返回-1

 7、substring(int a,int b)：截取当前字符串指定范围的字符串-----输出String

                                          a开始截取的下标   b结束截取的下标（含头不含尾，同随机数）

//                      1
//            01234567890
String str = "www.tedu.cn";
String subs = str.substring(4,8);//截取下标4到7范围的字符串---tedu
String subs1 = str.substring(4);//截取从下标4开始一直到结束的字符串---tedu.cn

获取域名：第1个点和第2个点之间的----就是域名

public class LocalTest {
    public static void main(String[] args) {
        String name1 = "www.tedu.cn";
        String name2 = "www.tarena.com.cn";//找第2个点
        String name3 = "http://www.google.com";
        String s1 = getName(name1);
        System.out.println(s1);//tedu
        String s2 = getName(name2);
        System.out.println(s2);//tarena
        String s3 = getName(name3);
        System.out.println(s3);//google
    }

    //获取给定网址中的域名 line：网址  返回域名
    //第1个点和第2个点之间的就是域名
    public static String getName(String line){
     // 或者line.substring(line.indexOf(".")+1,line.indexOf(".",line.indexOf(".")+1));
        int start = line.indexOf(".")+1;
        int end = line.indexOf(".",start);
        return line.substring(start,end);
    }
}

8，静态方法valueOf() ：将其他数据类型转换为String-----输出String

                                        静态方法用String（类名）打点访问

int a = 1234;
String value1 = String.valueOf(a);//将int类型转换为String类型
System.out.println(value1);//字符串"1234"

double b = 1234.567;
String value2 = String.valueOf(b);//将double类型转换为String类型
System.out.println(value2);//字符串"1234.567"

String c = "a" + "";//任何内容和字符串连接的结果都是字符串，但是效率低
System.out.println(c);//也是字符串"1234"

 StringBuilder类

由于String是不变对象，每次修改内容都要创建对象造成内存泄漏，因此String不适用频繁的修改操作，为了解决这个问题，java提供了StringBuilder类，String适用于：查找但不用修改

StringBuilder是专门用于修改字符串的一个API，内部维护了一个char数组，修改都是在这个数组上进行的，修改速度、性能优秀，并且提供了修改字符串的常见的方法：增、删、改、插。

//String不适用频繁增删修改内容
String s = "a";
for(int i=0;i<10000000;i++){
     s = s + i;
//每循环一次都会在内存中分配一个对象，内存泄漏！
   }
System.out.println("执行完毕");
//用StringBuilder可提高修改字符串的性能
StringBuilder builder = new StringBuilder("a");
for(int i=0;i<10000000;i++){
     builder.append(i);//数组的追加
//每次循环可在原有字符串上进行修改，不用新创建对象
   }
System.out.println("执行完毕");

 StringBuilder常用方法

1、append()：追加内容

2、replace()：替换部分内容

3、delete()：删除部分内容

4、insert()：插入内容

5、reverse()：翻转内容

String str = "好好学习java";
StringBuilder builder = new StringBuilder(str);
System.out.println(builder);
//复制str的内容到builder中----好好学习java

//append()追加内容
builder.append(",将来找个好工作!");
System.out.println(builder);//好好学习java，将来找个好工作

//replace()替换部分内容
builder.replace(9,16,"就是为了改变世界");//9：将；16：！
System.out.println(builder);//替换时：含头不含尾
//好好学习java，就是为了改变世界

//delete()删除部分内容
builder.delete(0,8);//删除下标0到7的
System.out.println(builder);//,就是为了改变世界

//insert()插入内容
builder.insert(0,"活着");//从下标0的位置开始插入
System.out.println(builder);//活着，就是为了改变世界

//reverse()翻转
builder.reverse();//翻转内容
System.out.println(builder); //!界世变改了为是就，着活

补充：

1、StringBuilder和StringBuffer

     （1）StringBuffer：是线程安全的，同步处理的，性能稍慢

     （2）StringBuilder：非线程安全的，并发处理的，性能稍快

2、getter/setter：创建方法用来获取其他类private访问权限的实例变量

public class Point{
   private int x;
   private int y;

 public int getX(){//getter获取值
    return x;
   }

 public int getY(){
    return y;
   }

public void setX(int x){//setter设置值
   this.x = x;
   }

public void setY(int y){
    this.y = Y;
   }
}

public class Test(){
   public static void main(String[] args){
   Point p = new Point();
   p.setX(100);//赋值
   p.setY(200);
   System.out.println("getX:"+p.getX()+",getY:"+p.getY());
}
   

正则表达式

正则表达式是用来描述字符串内容格式，使用它通常用来匹配一个字符串的内容是否符合要求

语法：

[]表示一个字符，该字符可以是[]中指定的内容
例如
[abc]可以表示abc中的任意一个字符
[a-z]表示a到z中的任意一个字符
[A-Z]表示A-Z中的任意一个字符
[0-9]表示0-9中的任意一个数字
[a-zA-Z0-9_]表示数字字母下划线中的任意一个
[^abc]表示该字符只要不是a或b或c

预定义字符
.：表示任意一个字符，没有范围限制
\d:表示任意一个数字，等同于[0-9]
\w：表示一个单词字符，等同于[a-zA-Z0-9_]
\s:表示任意一个空白字符（看不见的空格、换行符等）

\D:表示不是数字
\W：表示不是单词字符
\S:表示不是空白字符

量词:
?:表示前面的内容出现0-1次
  例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
+:表示前面的内容最少出现1次
  例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcbabcbabbabab....
        但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
*:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
  例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcbabcbabbabab....或什么也不写
        但是不能匹配:abcfdfsbbaqbb34bbwer...
{n}:表示前面的内容出现n次
  例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
        但是不能匹配: aaaa 或 aad
{n,m}:表示前面的内容出现最少n次最多m次
  例如: [abc]{3,5} 可以匹配:aaa 或  abcab 或者 abcc
        但是不能匹配:aaaaaa 或 aabbd
{n,}:表示前面的内容出现n次以上(含n次)
  例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcbabcba....
        但是不能匹配:aa 或 abbdaw...
()用于分组,是将括号内的内容看做是一个整体
  例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
        但是不能匹配aaa 或abcabc
        (abc|def){3}表示abc或def整体出现3次.
        可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
        但是不能匹配abcdef 或abcdfbdef

邮箱：

String方法：用于正则表达式

1、matches(String regex)：使用给定的正则表达式验证当前字符串的格式是否满足要求

String email = "abcd@tedu.com";
String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
boolean match = email.matches(regex);
if(match){
    System.out.println("满足邮箱格式要求");
   }else{
    System.out.println("不满足邮箱格式要求");
   }
//输出：满足邮箱格式要求

2、split(String regex)：将当前字符串暗战给定的正则表达式进行拆分-----输出String[]数组

String line = "abc123def456ghi";
String[] data = line.split("[0-9]+");//按数字拆分
System.out.println(Arrays.toString(data));//[abc,def,ghi]

line = "123,456,789,000";
String[] data = line.split(",");//按逗号拆分
System.out.println(Arrays.toString(data));//[123,456,789,000]

line = "123.456.789.000";
String[] data = line.split("\\.");//按点拆分
//.前面第1个\代表正则的转义符
//但在java中，\也属于特殊字符，所以\也得转义，前面要再加一个转义符\
//\\.在执行过程中最终识别为.
System.out.println(Arrays.toString(data));//[123,456,789,000]

//最开始就是可拆分项，那么数组中的第1个元素为一个空字符串
//如果连续两个（两个以上）可拆分项，它们中间也会拆出一个空字符串
//如果末尾连续多个可拆分项，那么拆出的空字符串被忽略
line = "..123.456....789.000.....";
String[] data = line.split("\\.");
System.out.println(Arrays.toString(data));//[,,123,456,,,,789,000]

3、replace(String regex,String str)：将当前字符串中满足正则表达式的部分替换为给定的字符串

String line = "abc123def456ghi";
String data = line.replace("[0-9]+","#NUMBER#");//按数字拆分
System.out.println(line);//abc#NUMBER#def#NUMBER#ghi

Object：对象/东西

1、是所有类的鼻祖（java.lang.Object），所有类都直接或间接继承了Object，万物皆对象，为了多态

2、Object中有几个经常被派生类重写的方法：toString()和equals()

    （1）调用toString()时默认返回：类的全称@地址，没有参考意义，所以常常重写toString()

             返回具体数据

    （2）调用equals()时默认比较的还是==（比较地址），没有参考意义，所以常常重写equals()来

             比较具体的属性值

            需要注意：java提供的类（String、StringBuilder）都已经重写equals()方法了，但我们自己

            定义的类必须要重新写equals()

派生类重写equals()的基本规则：

（1）两个对象必须是同一个类型，否则返回false

（2）若参数属性为null，则返回false

（3）原则上两个对象要比较对象的属性是否相同

重写方法：快捷键：Alt+insert

public class ObjectDemo{
     Point p = new Point(100,200);
     System.out.println(p);
//输出引用调用时默认调用toString()
//相当于System.out.println(p.toString());
//若不重写toString()，输出的是一个:包名.类名@地址，在实际开发中，这个结果没有意义

String str = "这是个点" + p;
System.out.println(str);
//字符串连接时将默认调用对象的toString()
//相当于 String str = "这是个点" + p.toString();
//输出：这是个点+p的地址

Point p1 = new Point(100,200);
Point p2 = new Point(100,200);
System.out.println(p1==p2);//比较p1和p2的地址，false
System.out.println(p1.equals(p2));
//若不重写equals(),p1.equals(p2)默认比较的是p1和p2的地址
//重写后，比较的是两个对象的属性

包装类

1、java定义了8个包装类，也是引用类型，目的是为了解决基本类型不能直接参与面向对象开发的问题，使得基本类型可以通过包装类的实例以对象的方式存在

2、包括：Integer、Character、Byte、Short、Long、Float、Double、Boolean。

     其中Character和Boolean是直接继承Object的，其余6个包装类都继承java.lang.Number

3、JDK1.5推出了一个新的特性：自动拆装箱，该特性是编译器可以，当编译器编译时若发现有基本类型与包装类型相互赋值时，会自动补充代码来完成他们的转化工作，这个过程称为自动拆装箱

    把基本类型转换为包装类型的过程叫做装箱(boxing)

    反之，把包装类型转换为基本类型的过程叫做拆箱(unboxing)。

4、自动装箱时是由编译器默认调用Integer.valueOf()方法

      valueOf()：将基本类型转换为包装类

                        将字符串转换为包装类（Character除外）

      xxxValue()：将包装类转换位基本数据类型

      对valueOf()方法有一个优化，若数字为-128到127之间的，则复用

     自动拆箱：当Integer和int对比时，Integer会自动拆箱为int类型

//演示自动拆装箱
Integer i1 = 5;
//触发了自动装箱特性，会被编译为：Integer i1 = Integer.valueOf(5);
int i2 = i1;
//触发了自动拆箱特性，会被编译为：int i2 = i1.intvalue();

//演示包装类的实际操作：
Integer max = Integer.MAX_VALUE;//获取int的最大值
Integer min = Integer.MIN_VALUE;//获取int的最小值

Double dmax = Double.MAX_VALUE;//获取double的最大值
Double dmin = Double.MIN_VALUE;//获取double的最小值

Integer a = 100;//自动装箱，a是一个对象
Integer b = 100;//自动装箱，因值在-128到127之间，所以复用了a对象
System.out.println(a==b);//true，因为复用个100那个对象

Integer c = 200；//自动装箱，c是一个对象
Integer d = 200；//自动装箱，但数据不在复用范围内，所以d是另一个对象
System.out.println(c==d);//false，因为这两个对象的地址不同

int e = 200;
//Integer和int对比时，Integer会自动拆箱为int类型
System.out.println(d==e);//true

包装类还可以将字符串转化为对应的基本类型

parsexxx()：将字符串转换为为基本数据类型 (Character除外)

//前提是该字符串正确表达了基本类型的值
//若不能正确表达，则发生NumberFormatException数字转换异常
String str = "123";
int num = str.parseInt(str);//将字符串str转换为int类型
System.out.println(num);//输出int类型

String str1 = "123.456";
double num2 = str1.parsDouble(str1);//将字符串str1转换为double类型
System.out.println(num1);//输出double类型

toString()：将包装类转换为字符串

                   更常用的方法：加上空字符串，强制转换

Integer i = 100;
String s = i.toString();
String s1 = i + "";//加上空字符串转换为String类型

 5、包装类：Boolean

//对于Boolean来说，当形参是"true"时，返回true，除此之外，返回"false"
Boolean bo = new Boolean("true");
System.out.println(bo);//true
bo = new Boolean("abv");
System.out.println(bo);//false

补充：

1、包装类型可以为null，而基本类型不可以，包装类型

2、包装类型可用于泛型，而基本类型不可以

     泛型不能使用基本类型，因为使用基本类型时会编译出错：泛型在编译时会进行类型擦除，最

      后只保留原始类型，而原始类型只能是Object类及其子类--基本类型是个特例。

3、基本类型比包装类型更高效：基本类型在栈中直接存储的具体数值，而包装类则存储的是堆中

     的引用

 相比较与基本类型而言，包装类型需要占用更多的内存空间，假如没有基本类型的话，对于数值这类经常使用到的数据来说，每次都要通过new一个包装类型就显得非常笨重。

常量池

java对字符串有一个优化措施：字符串常量池（堆中）

java推荐我们使用字面量/直接量方式来创建字符串，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相同字面量再将创建字符串时会重用对象以减少内存开销，避免内存中堆积大量内容相同的字符串对象

public class StringDemo {
    public static void main(String[] args) {
       //直接双引号赋值的称为“字面量”
        String s1 = "abc123";//常量池还没有，因此创建了该字符串对象，并存入常量池中
        String s2 = "abc123";//常量池有该字符串，直接拿来用，s1与s2地址相同
                             //s2复用了这个对象
        System.out.println(s1==s2);
        s1 = s1 + "!";//堆中会创建了一个新的对象"123abc!"，并将地址赋值给s1，
                      //因为不是直接用字面量赋值，所以生成的对象"123abc!"不会存在常量池中
                      //只是在堆中创建对象
        System.out.println(s1==s2);
    }
}
//输出：true
       false

字面量赋值会存储在常量池中，用字符串连接符（+）连接后再赋值的在常量池中没有分配

public class StringDemo {
    public static void main(String[] args) {
        String s1 = "123abc";//堆中会创建一个"123abc"的对象，常量池中有一个"123abc"的地址
        String s2 = "123" + "abc";//复用常量池中的对象
                            //编译器在编译时，若发现时两个字面量操作，
                           //则直接运算好并将结果保存到表达式中，相当于String s2 = "123abc";
        System.out.println(s1==s2);
        String s3 = "123";
        String s4 = s3 + "abc";
       //不是两个字面量操作，编译器不能直接确定值，会在堆中创建新的对象，而不会复用常量池中的对象
        System.out.println(s1==s4);
    }
}
//输出：true
       false

面试题：

1、String s = new String("hello");

      如上语句创建了几个对象？------------2个

/*
String s = new String("hello");
第1个：先创建了字面量"hello"
        ---java会创建一个String字面量对象表示字面量"hello",并将其存入常量池
  第2个：new String()
        new String()时会再创建一个String字符串对象，并引用hello字符串的内容
*/

String s = new String("hello");
String s1 = "hello";
System.out.println(s);//hello
System.out.println(s1);//hello
System.out.println(s==s1);//比较两个字符串地址是否相同，false

//字符串实际开发中比较相等一般都是比较字符串中的内容
//因此我们需要使用equals()方法来比较两个字符串的内容
System.out.println(s.equals(s1));//true

 内存分析：

2、java是值传递还是引用传递：

     java中无论是基本类型还是引用类型，都是值传递

    （1）对于基本类型而言，传递的是具体的值的副本

    （2）对于引用类型而言，传递的是具体的地址的副本

int a = 5;
int b = a;//是将a的值5传递给b了-----传递的是具体的值的副本
System.out.println(b);//5

Moo o1 = new Moo();
Moo o2 = o1;//是将o1的地址赋值给了o2----传递的是具体的地址的副本
System.out.println(o1);//输出的是地址
System.out.println(o2);//输出的也是地址，且与o1的地址相同

3、==和aquals的区别：

（1）==：对于基本类型而言，比较的是数值是否相等

                 对于引用类型而言，比较的是内存地址是否相等

（2）equals：比较的是两个对象的内容是否相等