我的java笔记(异常,字符串)

异常和字符串操作是以后会经常使用到的知识.下面是我看毕向东老师的视频总结的知识点:

一:异常:
程序出现的不正常的情况,叫异常
1:在java中有很多的异常,这些异常有共性内容,不断抽取,就形成了异常体系
  这个体系结构中超类是:Throwable
  Throwable:包括Error和Exception
Error:指的是严重的问题,严重到影响程序的执行,这个问题,不做异常处理.因为一般出现的问题,处理不了.比如内存溢出.
  jvm默认内存是64M.
Exception:一般的程序问题,必须通过异常处理的. 
  一般,通过看一个问题的后缀就知道该问题是哪种体系下的.

2:Throwable中的三个方法:
  String getMessage():获取异常信息,返回字符串.
  void printStackTrace():获取异常的堆栈信息(常用).
  String toString():获取异常字符串信息.

3:main方法中如何处理异常(一):
(1):main里面如果没有处理异常,那么jvm会采用默认处理方式.
  默认处理会显示异常的位置,异常的原因,属于哪个异常类.
(2):自己写代码处理:
     A:try...catch...finally 捕获异常.
  基本格式:
  try
  {
   可能出现异常的代码;
  }catch(异常类 变量){
   异常的处理方式
  }
  finally{
  释放资源;
  }
   如果没有做异常处理,程序在哪个地方出异常,就会在哪个地方退出执行.
   多个catch的时候,谁先catch无影响.它是根据语句的执行顺序走的,前提是:这多个catch不能存在子父关系.
   如果多个异常间有继承关系:一定要把父异常放在最后.子异常放在前面.
   finally代码块中的内容,永远都会执行,一般用于释放资源.
   System.exit(0);退出jvm.如果此语句在finally语句前,则不会执行finally语句.

4:处理异常(二):通过throws关键字抛出异常
格式:throws 异常名  如:throws Exception
通过throws关键字,一般是声明异常,告诉调用者我的方法有问题,你需要处理.
而处理方式又有两种:
要么throws.但是在主方法中,建议不要抛出,直接try...catch
要么try...catch...

5:Exception和RuntimeException的区别:

A:Exception:一般性的错误，是需要我们编写代码进行处理的。
  
B:RuntimeException:运行时异常，这个我们也不需要处理.
         其实就是为了让他在运行时出问题，然后我们回来修改代码。

         在用throws抛出一个的时候，如果这个异常是属于RuntimeException的体系的时候，
  我们在调用的地方可以不用处理。(RuntimeException和RuntimeException的子类)
 
  在用throws抛出一个异常的时候，如果这个异常是属于Exception的体系的时候，
  我们在调用的地方必须进行处理或者继续抛出。

6:自定义异常:
因为项目中会出现特有的问题,而这些问题并未被java所描述并封装对象,所以对于这些特有的问题可以按照
java的对问题封装的思想,将特有的问题,进行自定义的异常封装.
一般是继承自Exception或者RuntimeException
如何定义异常信息呢?
因为父类中已经把异常信息的操作都完成了,所以子类只要在构造时,将异常信息传递给父类通过super语句.那么就可以
直接通过getMessage方法获取自定义的异常信息.

继承Exception的原因:
异常体系有一个特点:因为异常类和异常对象都被抛出.
他们都具备可抛性,这个可抛性是Throwable这个体系中独有特点.
只有这个体系中的类和对象才可以被throws和throw操作.

7:throws和throw的区别:
A：有throws的时候可以没有throw。
  有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
  在用throws抛出的时候,如果这个异常会是属于RuntimeException体系的时候我们在调用的地方可以不用处理
B：throws用于方法的声明上，其后跟的是异常类名
     throw用于方法体中，其后跟的是异常对象
   
例:
继承Exception
class MyExcepiton extends Exception
{
MyExcepiton(){}

MyExcepiton(String message)
{
  super(message);
}
}
class Test{
public int div(int a,int b)throws MyException{//方法上先声明异常
  if(b<0){
   throw new FuShuException("分母为负数异常,----/by fushu:");             //方法内部出现异常
  }
  return a/b;
}
}
////////////

继承RuntimeException

class MyException extends RuntimeException
{
MyExcepiton(){}

MyExcepiton(String message)
{
  super(message);
}
}
class Test{
public int div(int a,int b){//方法上先声明异常
  if(b<0){
   throw new FuShuException("分母为负数异常,----/by fushu:");             //方法内部出现异常
  }
  return a/b;
}
}

例:
class MyException extends RuntimeException
{
private int num;

MyException(){}

MyException(String message)
{
  super(message);
}

MyException(String message,int num)
{
  super(message);
  this.num = num;
}

public int getNum()
{
  return num;
}
}

class MathDemo
{
public int divide(int a,int b)throws MyException
{
  if(b<0)
  {
   throw new MyException("除数不能为负数",b);
   //MyException my = new MyException("除数不能为负数");
   //throw my;
  }
  else
  {
   return a/b;
  }
}
}

class ExceptionDemo9
{
public static void main(String[] args)
{
  MathDemo md = new MathDemo();
  System.out.println(md.divide(10,-2));
}
}

面试题:
1:final,finally,finalize的区别?
final是最终的意思,它可以用于修饰类,成员变量,成员方法,它修饰的类不能被继承,它修饰的变量是常量,它修饰的方法是不能被复写.
finally:是异常处理中的关键字.它其中的代码用于被执行.特殊情况:在执行它之前jvm退出.
finalize:是Object类中的一个方法.它是于垃圾回收器调用的方法.
2:如下代码所示:
class FinallyDemo{
public static void main(String[] args){
  try{
       System.out.println("AAAAA");
       System.out.println(10/0);
       System.out.println("BBBBBBB");
  }catch(Exception e){
       System.out.println("CCCCCC");
       return;
  }
  finally{
       System.out.println("DDDDDD");
  }
  System.out.println("EEEEEEE");
}
}
执行结果是:AAAAAA,CCCCCCCCCC,DDDDDD
finally会在return;前执行,
return;相当于停止运行程序.

二:Eclipse:
1:由IBM一个小组开发.
2:特点:
完全由java语言编写.
不需要安装
免费的,官网:www.eclipse.org
开源的.
扩展性非常强
3:eclipse和Myeclipse的区别
A:MyEclipse是基于eclipse加入了一些用常用的开发web的插件,插件收费
B:Myeclipse集成性很好,收费.
4:在使用eclipse之前,系统中必须要先有jdk或者jre.

三:Runtime类:调用windows系统资源.
大部分方法都不是静态的,说明我们需要创建对象调用.而没有提供构造方法.
这是使用单例设计模式体现的
public class RuntimeDemo {

public static void main(String[] args) {
  Runtime rt = Runtime.getRuntime();

  try {
   //rt.exec("d:\\winmine.exe");
   //rt.exec("d:\\winmine");
   //rt.exec("winmine");  //path路径中扫雷
   rt.exec("notepad");        //文本框
  } catch (IOException e) {
   e.printStackTrace();
  }
}

}

四:System类
System.exit(int i);结束程序,i为0表示程序正常退出,i非0表示程序异常退出.
static long currentTimeMillis() 返回以毫秒为单位的当前时间。

模版设计模式:
给你一个模式,你照着做就行.把抽象的部分抽象出来,将来供子类来实现.
好处:提高代码的扩展性.
例://得出程序运行时间.
public abstract class GetTime {

public long getTime() {
  long start = System.currentTimeMillis();

  // 被测试的代码
  code();

  long end = System.currentTimeMillis();

  return end - start;
}

/*public void code() {
  for (int x = 0; x < 10000; x++) {
   System.out.println("x:" + x);
  }
}*/

public abstract void code();
}

字符串:
一:
1:字符串是一个特殊的对象也,字符串一旦被赋值不可以改变.
在Object中equals()方法是判断两个值的地址值是否相同.而在String中则是判断字符串是否相同.

2:通过构造创建对象和直接赋值创建对象的区别
   String s1="abc";和String s2=new String("abc");
s1在内存中有一个对象(在常量池中).
s2在内存中有两个对象,一个是"abc"对象,一个是s2对象

例: String s1="abc";
String s2=new String("abc");
String s3="abc";
  s1.equals(s2);true
  s1==s2        false
  s1==s3        true
s1==s3,在字符串在内存(常量池,常量池和静态区都在方法区中)中如果有了"abc",那么s3将会直接指向"abc"
        所在的地址.

二:常用构造方法:
String s=new String();
String s=new String(byte[] bytes);byte数组中的数据是字符的ASCLL码值.
String s=new String(byte[] bytes,int offset,int length);指定byte数组的起始位置和截取长度.
String s=new String(char[] value);字符数组作为字符串的参数.
String s=new String(char[] value,int offset,int length);
String s=String(String str)  初始化一个新创建的 String 对象.
String s=String(StringBuffer buffer) 分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
String s=String(StringBuilder builder) 分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

三:常见的字符串操作:具体看API文档
1:判断:
2:boolean startsWith(str)判断字符串是否是以str开头
  boolean endsWith(str)判断字符串是否是以str结尾
  boolean isEmpty()判断是否字符串长度为0
  boolean contains(String str)判断字符串中是否包含str字符串.
3:boolean equals(String str):判断字符串内容是否相同.复写了Object类中的equals();
  boolean equalsIgnoreCase(String str);忽略大小写判断字符串内容是否相同.

4:查找:如果没有找到则返回-1
  int indexOf(int ch)获取ch(字符的ASCLL码值,也可以使字符)在字符串中第一次出现的位置.如果没有找到返回-1
  int indexOf(int ch,int fromIndex)从fromIndex位置开始,获取ch在字符串中出现的位置.如果没有找到返回-1
  int indexOf(String str);返回str在字符串中第一次出现的位置.
  int indexOf(String str,int fromIndex);从fromIndex指定位置开始,获取str在字符串中出现的位置.
  int lastIndexOf(int ch)
          返回指定字符在此字符串中最后一次出现处的索引。
  int lastIndexOf(int ch, int fromIndex)
          返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
  int lastIndexOf(String str)
          返回指定子字符串在此字符串中最右边出现处的索引。
  int lastIndexOf(String str, int fromIndex)
          返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

5:获取字符串中的一部分; 包含头不包含尾
    int length();获取字符串长度
    char charAt(int index)获取index为位置上的字符.
    String substring(int beginIndex)从指定位置到结尾 
    String substring(int beginIndex, int endIndex) 从头开始,到endIndex-1处.

6:转换.
  静态方法:
    static String copyValueOf(char[])将字符数组转换成字符串
    static String copyValueOf(char[] data,int offset,int count)将从offset开始的count个字符转成字符串.
    Static String valueOf(char[])

    char[] toCharArray()将字符串变成字符数组
    byte[] getBytes()将字符串变为字节数组,为字符的Ascll码值
   将基本数据类型转成字符串.
static String valueOf(boolean b) 返回 boolean 参数的字符串表示形式。
static String valueOf(char c) 返回 char 参数的字符串表示形式。
  static String valueOf(char[] data) 返回 char 数组参数的字符串表示形式。
static String valueOf(char[] data, int offset, int count) 返回 char 数组参数的特定子数组的字符串表示形式。
static String valueOf(double d) 返回 double 参数的字符串表示形式。
static String valueOf(float f) 返回 float 参数的字符串表示形式。
static String valueOf(int i) 返回 int 参数的字符串表示形式。
static String valueOf(long l) 返回 long 参数的字符串表示形式。
static String valueOf(Object obj)  返回 Object 参数的字符串表示形式。
  
7:转换大小写:都生成新字符串,需要接收
    String toUpperCase();转大写
    String toLowerCase();转小写

8:替换:需要一个新的字符串接收
    String replace(oldchar,newchar);用新字符替换旧字符,如果有多个相同的字符,则替换所有的相同的字符.
    String replace(CharSequ ence target, CharSequence replacement)用新子串替换旧子串.

9:切割:
    String[] split(regex);用String数组接收,以regex为分割符
String str="王,广,彬";
String[] str=str.split(",");
10:去除字符串两端空格:
    String trim()  ;
11:字符串比较: 返回的是两数Ascll码值的差.
     int compareTo(String anotherString)
          按字典顺序比较两个字符串。
     int compareToIgnoreCase(String str)
          按字典顺序比较两个字符串，不考虑大小写。
12:字符串的连接:
      String concat(String str) 将指定字符串连接到此字符串的结尾。

例1:/*
从键盘输入一个字符串,把它变成首字母大写,其他字母小写的字符串,
*/
import java.util.*;
public class StringDemo3 {
public static void main(String[] args) {
  Scanner sr=new Scanner(System.in);
  System.out.println("请输入:");
  String str=sr.nextLine();
  Change c=new Change();
  System.out.println(c.get(str));
}
}
class Change{
public String get(String str){
  String s1=str.substring(0,1).toUpperCase();  //获取第一个字符,并转换成大写
  String s2=str.substring(1).toLowerCase();    //获取从1到结尾的字符,并转换成小写
  String s3=s1.concat(s2);                    //将两个字符串连接起来.
  return s3;
}
}

例2:
例:
//打印输出字符串中出现数字大小写字母的次数.
import java.util.Scanner;
public class StringDem2 {
public static void main(String[] args) {
  Scanner sr=new Scanner(System.in);
  System.out.println("请输入:");
  String str=sr.nextLine();
  Get get=new Get();
  get.getNumber(str);
System.out.println("数字出现:"+get.arr[0]+"...小写字母出现:"+get.arr[1]+"...大写字母出现:"+get.arr[2]);
}
}
class Get{
int arr[]={0,0,0};  //用于存储数字,大小写字母出现的次数.
public Get(){}
public int[] getNumber(String str){
  for(int i=0;i<str.length();i++){
   char c=str.charAt(i);
   if(c>='0'&&c<='9'){    //0-9的Ascll码值是48-57
    arr[0]++;
   }else if(c>='a'&&c<='z'){   //a-z的Ascll码值是97-122
    arr[1]++;
   }else if(c>='A'&&c<='Z'){   //A-Z的Ascll码值是65-90
    arr[2]++;
   }
  }
  return arr;      //返回arr数组.
}
}

例3
例:
/*
模拟登录,给三次机会,并提示还有几次,
默认密码的用户名和密码是admin,区分大小写
自己从键盘输入用户名和密码.
*/
import java.util.Scanner;
public class StringDemo {
public static void main(String[] args) {
  Scanner sr=new Scanner(System.in);
  int n=3;
  for(int i=1;i<=3;i++){
   System.out.println("请输入用户名:");
   String str1=sr.nextLine();
   System.out.println("请输入密码:");
   String str2=sr.nextLine();
   if(str1.equals("admin")&&str2.equals("admin")){
    System.out.println("登录成功,欢迎你的登录!");
    break;
   }else{
   
    n--;
    if(n>0){
     System.out.println("你输入的密码或用户名错误,请重新输入.");
     System.out.println("你还有"+n+"次机会!");

    }
    if(n<=0){
     System.out.println("登录已超过三次,请三个小时后");
    }
   }
  }
}
}

三:StringBuffer字符串缓冲区,缓冲区用于存储数据.也成为容器
1:特点:
A:长度是可变化的.提高了内存空间的使用率.
B:可以操作多个数据
C:最终会通过toString方法变成字符串
D:String转换成StringBuffer可以通过带参构造完成.
StringBuffer是一个长度可变化的容器,可以存储,删除,获取,修改,
2:构造函数:
new StringBuffer()
new StringBuffer(int capacity)指定StringBuffer容量
new StringBuffer(String str)
增删改查(curd):c create u update r read d delete
3:添加
StringBuffer append(任意类型数据)在末尾处添加数据.
StringBuffer insert(index,数据)将数据插入到index处.
String toString()将StringBuffer类型变成字符串类型.
4:删除
StringBuffer delete(int start, int end)删除指定范围的字符,包含start,不包含end.
StringBuffer deleteCharAt(int index)  删除指定位置的字符.
5:查找
char charAt(int index)  获取index处的字符
int indexOf(String str)  返回第一次出现的指定子字符串在该字符串中的索引。
int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引
6:获取
String substring(int start)本身不变 返回一个新的字符串，它包含此字符序列当前所包含的字符子序列。
String substring(int start, int end)本身不变 返回一个新的 String，它包含此序列当前所包含的字符子序列。
7:替换
StringBuffer replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。 
void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。 无返回值
8:
int capacity():返回当前容量(元素的理论值)   初始容量为16  以加1乘2增加.
int length():返回StringBuffer长度(元素的个数).

9:反转
  StringBuffer reverse() 将它本身反转.
          将此字符序列用其反转形式取代。

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将缓冲区的数据复制到目标字符数组中.

          将字符从此序列复制到目标字符数组 dst。

四:
StringBuffer和StringBuilder(jdk1.5之后才有):两者的功能一样,区别如下:
StringBuffer是线程同步 ,是线程不安全的.  
StringBuilder是线程不同步 效率比StringBuffer高,不保证线程安全,以后建议使用StringBuilder.

JDK版本升级三原则:
提高效率
简化书写
提高安全性

五:八种基本数据类型对象包装类(把基本数据类型转换成类)
1: byte    Byte
short   short
int     Integer
long    Long
boolean Boolean
float   Float
double  Double
char    Character
2:基本数据类型的对象包装类有什么作用?
(1):可以使我们对基本类型的数据进行操作.
(2):用于和字符串之间进行相互转换.
3:构造方法:
Integer(int i)
Integer(String s)   s必须是纯数字的字符串.
4:转换:
(1)将字符串转成基本数据类型: 
   static int parseInt(String s) 将字符串类型转换成整型数据.
(2)将基本数据类型转成字符串
  static String toString(基本数据类型值)
                static String valueOf(基本类型数据);
  String s=Integer.toString(num);
  String s=""+num;
(3)从基本数据类型和字符串转换到Integer
  static Integer valueOf(int i)
            返回一个表示指定的 int 值的 Integer 实例。
  static Integer valueOf(String s)
            返回保存指定的 String 的值的 Integer 对象。
例:
int num=Integer.parseInt("123");
long num=Long.parseLong("123");
字符串转为基本数据类型格式为:
数据类型 变量名=包装类名.parse包装类名("String");

static boolean parseBoolean(String s)
          将字符串转为为 boolean 值。

十进制转成其他进制:
static String toBinaryString(int i)
           以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
static String toHexString(int i)
           以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
static String toOctalString(int i)
           以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

其他进制转成十进制:
static int parseInt(String s)
           将字符串参数作为有符号的十进制整数进行解析。
例:Integer.parseInt("110",2);//2为二进制转成十进制
    Integer.parseInt("3c",16);//把16进制转换成十进制
    Integer.parseInt("110",8);//把八进制转成十进制
利用对象转换
例:Integer i=new  Integer("123");
   int num=i.intValue();

六::jdk1.5版本以后出现的新特性:

1:自动装箱拆箱
Integer x=4;//自动装箱,相当于Integer x=new Integer(4); 把基本数据变成对象类型
x=x+2;//自动拆箱,变成int类型x.intValue()和2进行加法运算,再将和进行装箱赋给x.
  当Integer x=null;时不能参加运算.

2:Integer m=128;
  Integer n=128;
  System.out.println(m==n);  //结果是false
  System.out.println(m.equals(n)); //true  , Integer覆写了Object的equals方法比较的是值.
 
  Integer a=127;
  Integer b=127;
  System.out.println(a==b);  //结果是true
  System.out.println(a.equals(b));//true

原因:因为当数值在byte范围内的时候,对于新特性,如果该数值已经存在,则不会再开辟新的空间.
128超出了byte的范围,所以为false,127在byte范围内所以a和b指向同一个Integer对象为true.