java从入门到精通

1.java_home

2

3

4

5

package com.example;
import java.util.Scanner;
public class Main {
   public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      System.out.println("请输入你的名字：");
      String name = scanner.nextLine();
      System.out.println("你好，" + name + "！");
   }
}

public class Fuzhi {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a,b,c; //声明int变量a,b,c
        a = 15; //将15赋值给a
        c = a; //将a的值赋给c
        b = a + 4; //将a与4的和赋值给变量b，然后给c
        c = b;  //将c的值赋给b
        System.out.println("c值为: "+c);
        System.out.println("b值为："+b);
    }
 
}

         public static void main(String[] args) {//主函数
          // TODO 自动生成的方法存根
          int a =1;//创整型量初始值为1
          System.out.println("a="+a);//输出此时a的值 
          a++;   // a自增+1
          System.out.println("a++="+a);//输出此时a的值 
          a++;  // a自增+1
          System.out.println("a++="+a);// 输出此时a的值 
          a++;  //a自增+1
          System.out.println("a++="+a);// 输出此时a的值 
          a--;  //a自减-1
            System.out.println("a--="+a);// 输出此时a的值
         }
    }

public static void main(String[] args) {//主函数
             
int num1 =4,num2=7; //声明int型变量num1，并赋值4，声明int型变量num2，并赋值7
int num3 =7;        //声明int型变量num3，并赋值7
System.out.println("numl<num2 的结果:"+(num1 < num2)); //输出numl<num2 的结果的值
System.out.println("numl>num2 的结果:"+(num1 > num2)); //输出numl>num2 的结果的值
System.out.println("num1==num2的结果:"+(num1 ==num2));//输出numl==num2 的结果的值
System.out.println("numl!=num2 的结果:"+(num1 != num2));//输出numl!=num2 的结果的值
System.out.println("numl<=num2的结果:"+(num1 <= num2));//输出numl<=num2 的结果的值
 System.out.println("num2>=num3的结果:"+(num2>= num3));//输出numl>=num2 的结果的值
   }
          }

public static void main(String[] args) {
        // TODO Auto-generated method stub
    byte mybyte = 27;
    int myint = 150;
    float myfloat = 452.12f;
    char mychar = 10;
    double mydouble = 45.46546;
    System.out.println("byte型与float型数据进行运算结果为:"+(mybyte+myfloat));
    System.out.println("byte型与int型数据进行运算结果为:"+(mybyte*myint));
    System.out.println("byte型与char型数据进行运算结果为:"+(mybyte/mychar));
    System.out.println("double型与char型数据进行运算结果为:"+(mydouble+mychar));
    }
 
}

int []array= {63,4,24,1,3,15};//创建数组,元素乱序
           LT sorter=new LT ();//创建直接排序类的对象
           sorter.sort(array);//调用排序对象,对数组排序
          }
          public void sort(int[]array) {
           for(int i=1;i<array.length;i++) {
            for(int j=0;j<array.length-i;j++) {
             if(array[j]>array[j+1]) {
              int temp = array[j];//把第一个元素值保存到临时变量中
              array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
              array[j+1]=temp;//把临时变量(第一个元素原值)保存到第二个元素单元中
             }
            }
           }
           showArray(array);//输出直接选择排序后的数组元素
          }
          
          public void showArray(int[]array) {
           for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
           }
           System.out.println();
           }
          }

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {10,20,30,40,50,60};    //创建一个数组
        LT sorter = new LT();//创建反转排序的对象
        sorter.sort(array);        //调用排序对象方法，将数组排序
    }
    public void sort(int[] array) {
        System.out.println("数组原有内容：");
        showArray(array);        //输出排序前的数组元素
        int temp;
        int len = array.length;
        for(int i = 0;i < len / 2;i++) {
            temp = array[i];
            array[i] = array[len - 1 - i];
            array[len - 1 - i] = temp;
        }
        System.out.println("数组反转后内容");
        showArray(array);        //输出排序后的数组元素
    }
    public void showArray(int[] array) {
        for(int i: array) {        //遍历数组
            System.out.print("\t"+ i); //输出每个数组元素值
        }
        System.out.println();
    
    }
}

public class part {
 public static void main(String [] args) {//主方法
  for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
   System.out.println(args[i]);//打印结果
  }
 }
}

运行需要的步骤：

选择自变量，输入参数，每个参数需要空格

运行结果

public class Student {      
 String name;
 int age;
 
 public Student(String name,int age) {
  this.name =name;
  this.age = age;
  
 }
 public String toString() {
  return "我叫"+name+",今年"+age+"岁。";
 }
 public static void main(String[] args) {
  Student s1 =new Student("张三",16);
  System.out.println(s1);
  Student s2 =new Student("李四",19);
  System.out.println(s2);
  
 }
}

public class People {
 
 int id; //身份证号
 String name; //名字
 public People(int id, String name) {
  this.id = id;
        this.name = name;
    }
  public boolean equals(Object obj) {//重写 Object 类的 equals()方法
   if(this==obj)//如果参数与本类是同一个对象
    return true;
   if(obj==null)//如果参数是null
    return false;
   if(getClass()!=obj.getClass())//如果参数与本类类型不同
    return false;
   People other = (People)obj;//将参数强转成本类对象
   if(id!=other.id)//如果两者的身份证号不相等
    return false;
   return true;
  }
  public String toString() {//重写 Object 类的 toString()方法
   return name;  //只输出名字
  }
  public static void main(String[]args) {
   People p1 = new People(220,"tom");
      People p2 = new People(220,"汤姆");
      People p3 = new People(330,"张三");
   Object o=new Object();
   System.out.println(p1+"与"+p2+"是否为同一人？"); 
         System.out.println("equals()方法结果:"+p1.equals(p2)); 
         System.out.println("==运算符的结果:"+(p1==p2));
 
         System.out.println(); 
         System.out.println(p1+"与"+p3+"是否为同一人？"); 
         
         System.out.println(p1.equals(p3));
         System.out.print(p1+"与"+o+"是否为同一人？");
         System.out.println(p1.equals(0));
     }
  
 }

class Dad{
    pubilc final void turnOnThe TV(){
        System.out.println("爸爸打开了电视");
}
}
class Baby extebds Dad{
    public final void turnOnThe TV(){
        System.out.println("宝宝也要打开电视");
}
  }

public void draw(Square s){    //绘制正方形的方法
}
     public void draw(Circular c){  //绘制圆形的方法
}

public class Shope { //图形类
 Square extends Shope{}  //正方形类继承图形类
 class Cirular extends Shape{}  //圆形类继承圆形类
 
 public static class Demo6{
  public static void draw(Shape s) {   //绘制方法
   if(s instanceof Square) {        //如果是正方形
    System.out.println("绘制正方形"); 
   } else if(s instanceof Circular) {  //如果是圆形
    System.out.println("绘制圆形");
   }else {
    System.out.println("【绘制父类图形");  //如果是其他类型
   }
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  draw(new Shape());
  draw(new Square());
  draw(new Circular());
 
 }
}
}

import com.mr*;     //导入com.mr包含中的所有类
 
import com.mr.Math  //导入com.mr包含Math类

public class c {
 private String brand;  //汽车品牌
 public c(String brand) {//汽车类的构造方法，参数为汽车品牌
  this.brand=brand; //给汽车品牌赋值
 }
 class En{   //发动机类（内部类）
  String model;  //发动机型号
  public En (String model) {  //发动机类的构造方法，参数为发动机型号
   this.model=model;   //给发动机型号赋值
  }
  public void ignite() {   //（发动机）点火方法
   System.out.println("发动机"+this.model+"点火");
 }
 }
 public void start() {  //启动（汽车）方法
  System.out.println("启动"+this.brand); 
  
  }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
    c c = new c("大众朗行");  //创建汽车类对象，并为汽车品牌赋值
    c.start();   //汽车类对象调用启动（汽车）方法
    //创建发动机类（内部类）对象，并为发动机型号赋值
    c.En engine = c.new En("EA211");
    engine.ignite();  //发动机类对象调用（发动机）点火方法2
   }
    }

public class TSN{
 private int x = 7;  //外部类的x
 private class Inner{
  private int x = 9;  //内部类的x
  private void doit() {
   int x = 11;  //局部变量x
   x++;
   this.x++;  //调用内部类的x
   TSN.this.x++;  //调用外部类的x
  }
  }
}

使用匿名内部类创建一个抽象类的对象

package package2;
 abstract class Dog {
     String Color;
     public abstract void move();
     public abstract void call();
    }
 
     public class Test2{
     public static void main(String[] args) {
      // TODO Auto-generated method stub
       Dog maomao = new Dog() {  //内部匿名类，补全方法
        public void move() {
         System.out.println("四腿狂奔");  //输出四腿狂奔
        }
        public void call() {
         System.out.println("嗷呜~");  //输出嗷呜
        }
       };
       maomao.Color = "灰色";
       maomao.move();
       maomao.call();
     }
 
    }

结果

public class Baulk {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int result=3/0;//定义int型变量并赋值
  System.out.println(result);//将变量输出
 }
 
}

public class Thundering {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str ="lili";//定义字符串
  System.out.println(str+"年龄是：");//输出提示信息
  int age =Integer.parseInt("20L");//数据类型转换
  System.out.println(age);//输出信息
 }
 
}
 

try{
//程序代码块

}

catch（Exceptiontype1 e）{
//对 Exceptiontype1 e的处理

}

catch（Exceptiontype2 e）{
//对 Exceptiontype2 e的处理

}

......

finally{
//程序代码块

}

完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下4种特殊情况下，finally块不会被执行：

1.在finally语句块中发现了异常

2.在前面的代码中使用了System.exit（）退出程序。

3.程序所在线程死亡。

4.关闭CPU。

public class Baulk {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  try {  //try语句包含可能出现的异常代码
  int result=3/0;//定义int型变量并赋值
  System.out.println(result);//将变量输出
  }catch(ArithmeticException e){//捕捉异常，算法异常
   System.out.println("捕捉到算法异常");//输出异常
  }finally {//最后结束
   System.out.println("程序结束");//输出语句
  }
 }
 
}

public class MyException extends Exception {//创建自定义异常，继承Exception类
 public MyException(String ErrorMessage) {//构造方法
  super(ErrorMessage);//父类构造方法
 }
}

public class Tran {
 static  int avg(int number1,int number2) throws MyException {//定义方法，抛出异常
  //number1和number2一定要在0~100之间
  if(number1<0 ||number2<0) {//判断方法中参数是否满足指定条件
   throw new MyException("不可以使用负数");//错误信息
  }
  
  if(number1>100 ||number2>100) {//判断方法中参数是否满足指定条件
   throw new MyException("数值太大 ");//错误信息
  }
  return (number1+number2)/2;//将参数平均值返回
 }
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  try {//try处理可能出现的异常代码
  int result =avg(2,5);//调用avg方法
  System.out.println(result);//将avg方法返回值输出
  }catch(MyException e) {//捕捉异常
   System.out.println(e);//输出异常信息
  }
 }
 
}

public class Shoot {//创建类
 static void pop()throws NegativeArraySizeException{
  //定义方法并抛出异常 NegativeArraySizeException异常
  int[]arr=new int[-3];//创建数组
 }
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  try {//try语句处理异常信息
   pop();//调用pop（）方法
  }catch(NegativeArraySizeException e) {
   System.out.println("pop()方法抛出异常");//输出异常信息
  }
 }
 
}

public class MyException1 extends Exception {//创建自定义异常类
 String message;//定义String类型的变量
 public MyException1(String err) {//父类方法
  message=err;
 }
 public String getMessage() {//对外提供getmessage方法
  return message;
 }
}

public class Captor {//创建类
 static int quotient(int x,int y)throws MyException1{//定义方法抛出异常
  if(y<0) {//判断参数是否小于0
   throw new MyException1("除数不能是负数");//异常信息输出
  }
  return x/y;//返回值
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  try {//try语句捕捉异常
   int result=quotient(3,-1);//调用quotient方法
  }catch(MyException1 e) {//处理自定义异常
   System.out.println(e.getMessage());//输出异常信息
  }catch(ArithmeticException e) {//处理ArrthmeticExceeption异常
   System.out.println("除数不能为0");//输出提示信息
  }catch(Exception e) {//处理其他异常
   System.out.println("程序发生了其他的异常");//输出提示信息
  }
 }
 
}

RuntimeException异常的种类

2.String(char a[],int offset,int lenght)该方法提取字符数组c中的一部分创建一个字符串对象。参数offest表示开始截取字符串的位置，lenght表示截取字符串的长度。char[] c = {'s','t','u','d','e','n','t'};
  String s = new String(c,1,3);//1为前索引，3为个数
  //两者等价于 String s = new String("tud")

3.String(char value)该构造方法可分配一个新的String对象，使其表示字符串数组参数中所有的元素连接的结果

char[] c = {'s','t','u','d','e','n','t'};
  String s = new String(c);
  //两者等价于 String s = new String("student")

除了以上几种使用String类的构造方法来创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串变量来创建字符串，代码如下：String str1,str2;
str1 = "we are students"
str2 = "we are students"

例题10.1【先连接对联的上，下联，再分行输出在控制台】

public class join {//创建类
 
 public static void main(String[] args) {//主方法
  // TODO 自动生成的方法存根
  String s1 = new String("春色绿千里");//声明String对象s1
  String s2 = new String("马蹄香万家");//声明String对象s2
  String s = s1 + "\n" + s2;//将对象s1,"\n"和对象s2连接并结果赋值给s
  System.out.println(s);//将s输出
 }
 
}

注意：
        只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。

如果将上例中的输出语句修改为：

System.out.println(”我每天花费”+booktime+”小时看书；"+(practice+booktime)+”小时上机练习”)；

由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，再将结果与字符串相连。

注意：

1 字符串在计算公式中的先后顺序会影响运算结果。
2 String a="1”+2+3+4 一“1234"             //碰到字符串后，直接输出后面内容
3 String b= 1+2+3+"4" 一"64”             //碰到字符串前，先做运算，后输出内容
4 String c="1"+(2+3+4)一"19”             //碰到字符串后，先运算括号中的值，后输出内容

例如，定义一个字符串num，使用length)方法获取其长度。代码如下：

String num ="12345 67890”;
int size = num.length();
将size输出，得出的结果就是：

11

String str = "we are students";
int size = str.indexOf("a");//变量size的值是3

2.lastindexOf(String str):该方法用于返回指定字符串最后一次出现的索引位置

str.lastindexOf(substr) 

str：任意字符串对象             sbustr：要搜索的字符串

public class Test {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String str = "we are students";//定义字符串str
  int size = str.lastIndexOf("");//将空字符串在str中的索引位置赋值给变量size
  System.out.println("空字符串在字符串str中的索引位置是："+size);//将变量size输出
  System.out.println("字符串str的长度是："+str.length());//将字符串str的长度输出
 }
 
}

例题10.4【查看指定索引位置上的字符】

public class Ref {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String str = "hello word";//定义字符串str
  char mychar = str.charAt(6);//将字符串str中索引位置是6的字符返回
  System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息
 }
 
}

beginIndex:指定从某一索引处开始截取字符串   代码如下：

String str = "hello word";
 
String substr = str.substring(3);

2、substring(int beginIndex,int endIndex)：  该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。

substring(int beginIndex,int endIndex)

beginIndex:开始截取子字符串的索引位置             endIndex:子字符串在整个字符串中的结束位置

例题10.5【《将进酒》的作者是谁】

public class Subs {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String str = "《将进酒》:李白(唐)";//定义的字符串
  String substr = str.substring(6,8);//对字符串进行获取
  System.out.print("《将进酒》的作者是："+ substr);//输出获取后的字符串
 }
 
}

例题10,6【去掉字符串首，尾的空格】

public class Black {
 //创建类
  public static void main(String[] args) {//主方法
   // TODO Auto-generated method stub
   String str = "   java  class   ";//定义字符串str
   System.out.println("字符串原来的长度："+str.length());
   //教案str原来的长度输出
   //将str去掉前导空格和尾部空格后的长度输出
   System.out.println("去掉空格后的长度："+str.trim().length());
  }
 
}

例题10.7【将单词a替换成A】

 
public class NewStr {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str = "address";//定义字符串str
  String newstr = str.replace("a", "A");
  //将str中“a”替换成“A”并返回新字符串newstr
  System.out.println(newstr);//输出
 }
 
}
 

例题10.8【判断字符串是否以指定的内容开始或结束】

public class StartOrEnd {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String num1 = "22045612";
  String num2 = "21304578";
  boolean b = num1.startsWith("22");//判断字符串num1是否以22开始
  boolean b2 = num2.endsWith("78");//判断字符串num2是否以78结束
  System.out.println("字符串num1是以‘22’开始的吗？"+b);
  System.out.println("字符串num2是以‘78’结束的吗？"+b2);//输出信息
 }
 
}

因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsignorecase()方法。
        3.equals()方法
        1.如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。语法如下：

str.equals(String otherstr)
    4.equalsIgnoreCase（）方法

例题10.9【判断“abc”与“ABC”是否相等】 

public class Opinion {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String s1 = new String("abc");
  String s2 = new String("ABC");
  boolean b = s1.equals(s2);
  boolean b2 = s2.equalsIgnoreCase(s2);
  System.out.println(s1 + "equals" + s2 + ":" + b);
  System.out.println(s1 + "equalsIgnoreCase" + s2 + ":" + b2);
 }
 
}

例题10.10【判断字母b的位置】

public class Wordbook {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String str = new String("b");
  String str2 = new String("a");
  String str3 = new String("c");
  System.out.println(str + "compareTo" + str2 + ":"
  + str.compareTo(str2));
  System.out.println(str + "compareTo" + str3 + ":"
    + str.compareTo(str3));
 }
}
 

例题10.11【字母大小写转换】

public class UpAndLower {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String str = new String("Oh My God");//创建字符串str
  String newstr = str.toLowerCase();//使用toLower方法实行大小写转换
  String newstr2 = str.toUpperCase();//使用toUpper方法实行大小写转换
  System.out.println(newstr);//将转换后的结果输出
  System.out.println(newstr2);
 }
 
}

例题10.12【按要求分割】 

public static void main(String[] args) {
  // TODO 自动生成的方法存根
  String str = "192.168.0.1";
  String[] firstArray = str.split("\\.");//按照"."进行分割，使用转义字符"\\."
  String[] secondArray = str.split("\\.",2);//按照"."进行两次分割，使用转义字符"\\."
  System.out.println("str的原值为：["+ str +"]");//输出str原值
  System.out.print("全部分割的结果为：");//输出全部分割的结果
  for(String a :firstArray) {
   System.out.print("["+ a +"]");
  }
  System.out.println();
  System.out.print("分割两次的结果：");//输出分割两次的结果
  for(String a : secondArray) {
   System.out.print("["+ a +"]");
  }
  System.out.println();
 }
 
}

例题10.13【按照格式化输出今天的年，月，日】

import java.util.Date;
public class Eval {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Date date = new Date();//创建Date对象date
  String year = String.format("%tY", date);//将date进行格式化
  String month = String.format("%tB", date);
  String day = String.format("%td", date);
  System.out.println("今年是："+year + "年");//输出信息
  System.out.println("现在是："+month);
  System.out.println("今天是："+day + "号");
  
 }
 
}

例题10.14【按照格式输出当下的时分秒】

import java.util.Date;
public class GetDate {
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Date date =new Date();//创建Date对象date
    String hour = String.format("%tH", date);//将date进行格式化
    String minute= String.format("%tM", date);
    String second = String.format("%tS", date);
    System.out.println("现在是："+hour+"时"+minute +"分"+second + "秒");//输出信息
 }
 
}

例题10.15【输出当下的年月日】

import java.util.Date;
public class DateAndTime {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Date date = new Date();//创建Date对象date
  String time = String.format("%tc", date);//将date格式化
  String form = String.format("%tF", date);
  System.out.println("全部的时间信息是："+ time);//将格式化后的日期时间输出
  System.out.println("年-月-日格式"+ form);
 }
 
}
 

例题10.16【使用转换符获取表达式的结果】 

public class General {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
String str=String.format("%d",400/2);//将结果以十进制格式显示
String str2=String.format("%b",3>5);//将结果以boolean型显示
String str3=String.format("%x",200);//将结果以十六进制显示z
System.out.println("400的一半是："+str);//输出格式字符串
System.out.println("3>5正确吗："+str2);
System.out.println("200的十六进制数是："+str3);
 }
 }

arg:将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。向字符串生成器中指定的位置添加字符，代码如下:

1 StringBuilder bf= new StringBuilder("hello")；//创建字符生成器
2 bf.insert(5，"world");//添加至字符生成器的位置及内容
3 System.out.println(bf.toString());//此时输出信息为hello word

删除指定位置的子字符串，代码如下:

1 StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器
2 bf.delete(5,10);//删除的子字符串
3 System.out.preintln(bf.toString());//此时输出的信息为Strinder

Double 类主要提供了以下常量:
MAX_EXPONENT:返回 int 值，表示有限 double变量可能具有的最大指数

MIN EXPONENT:返回int值，表示标准化 double变量可能具有的最小指数

NEGATIVE_INFINITY:返回 double值，表示保存 double 类型的负无穷大值的常量

 POSITIVE_INFINITY:返回 double值，表示保存 double类型的正无穷大值的常量

Boolcan 提供了以下3个常量：

TRUE:对应基值ie的 Boolean 对象

 FALSEr对应基值lse 的 Boolcan 对象
TYPE:基本类型boolean的Class对象

例题11.5【character类的常用方法】 

public class UpperOrLower {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Character mychar1 = Character.valueOf('A');
  Character mychar2 = Character.valueOf('a');
  if(Character.isUpperCase(mychar1));//判断是否为大写字母
  System.out.println(mychar1+"是大写字母");
  System.out.println("转换为小写字母的结果："+Character.toLowerCase(mychar1));
  if(Character.isLowerCase(mychar2)) {//判断是否为小写字母
   System.out.println(mychar2+"是小写字母");
   System.out.println("转换为大写字母的结果："+Character.toUpperCase(mychar2 ));
  }
  
 }
 
}
=

在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字行格式化设置。例如：

DecimalFormat myFormat = newDecimalFormat();//实例化decimalFormat类对象
myFormat.setGroupingSize(2);//设置将数字分组的大小
myFormat.setGroupingUsed(false）；//设置是否支持分组

例题11.7【]在Java代码中进行三角函数运算】 

public class TrigonometricFunction {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  System.out.println("90度的正弦值："+Math.sin(Math.PI/2));//取90的正弦
  System.out.println("0度的余弦值："+Math.cos(0));//取0的余弦
  System.out.println("60度的正切值："+Math.tan(Math.PI/3));//取60的正切
  System.out.println("2的平方根与2 商的反正弦值："+Math.asin(Math.sqrt(2)/2));
  System.out.println("2的平方根与2 商的反正弦值："+Math.acos(Math.sqrt(2)/2));
  System.out.println("1的反正切值："+Math.atan(1));//取1的反切值
  System.out.println("120度的弧度值："+Math.toRadians(120.0)); //取120的度的弧度值
  System.out.println("Π/2的角度值："+Math.toDegrees(Math.PI/2));//取Π/2的角度
  
 }
 
}

例题11.8【在Java代码中进行指数函数运算】

public class ExponentFunction {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  System.out.println("e的平方值："+Math.exp(2));//取e的2 次方
  System.out.println("以e为底2的对数值”"+Math.log(2));//取以e 为底2的对数
  System.out.println("以e为底2的对数值”"+Math.log(2));//取以10 为底2的对数
  System.out.println("4的平方根值："+Math.sqrt(4));//取4的平方根
  System.out.println("8的立方根值："+Math.cbrt(8));//取8的立方根
  System.out.println("2的2次方值："+Math.pow(2, 2));//取2的2次方
 }
 
}

3.取整函数方法

在具体的问题中，取整操作使用也很普遍，所以Java在Mah类中添加了数字取整方法。Mahx
中主要包括以下几种取整方法:
public static double ceil(double a): 返回大于等于参数的最小整数
public static double floor(double a): 返回小于等于参数的最大整数
public static double rint(double a): 返与参数最接近的整数，如果存在两个同样接近的整数.
则结果取偶数。
public static int round(float a): 将参数加上05 后返与参数最近的整数

public static longround(double a): 将参数加上05 后返与参数最近的整数，然后强制转换为长整型。

例题11.9【取最大值、最小值、绝对值的方法】
 

public class AnyFunction {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println("4和8较大值："+Math.max(4, 8));
  //取两个参数的最大值
  System.out.println("4.4和4较小值："+Math.min(4.4, 4));
  //取两个参数的最小值
  System.out.println("-7的绝对值："+Math.abs(-7));
  //取参数的绝对值
 }
 
}

以这种方式实例化对象时，Java 编译器将以系统当前时间作为随机数生成器的种子。因为解时刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两个运行结累的随机数。
用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下:

Random r = new Random(seedValue)

Random类对象。
 scedValue:随机数生成器的种子。

在Random 类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法：
 public int nextInt（）:返回一个随机整数。
 public int nextInt(int n): 返回大于等于0且小于n 的随机整数。
 public long nextLong(): 返回一个随机长整型值。
public boolean nextBoolean(): 返回一个随机布尔型值。
public float nextFloat(): 返回一个随机单精度浮点型值。
public double nextDouble(): 返回一个随机双精度浮点型值。
 public double nextGaussian():返回一个概率密度为高斯分布的双精度浮点型值

例题11.11【获取不同的取值范围，不同类型的随机数】
 

import java.util.Random;
public class RandomDemo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Random r = new Random();//实例化一个Random类
  //随机产生一个整数
  System.out.println("随机产生一个整数："+r.nextInt());
  //随机产生一个大于等于0小于10的整数
  System.out.println("随机产生一个大于等于0小于10的整数："+r.nextInt(10));
  //随机产生一个布尔型的值
  System.out.println("随机产生一个布尔型的值："+r.nextBoolean());
  //随机产生一个双精度浮点型的值
  System.out.println("随机产生一个双精度浮点型的值："+r.nextDouble());
  //随机产生一个单精度浮点型的值
  System.out.println("随机产生一个单精度浮点型的值："+r.nextFloat());
  //随机产生一个概率密度为高斯分布的双精度浮点型的值
  System.out.println("随机产生一个概率密度为高斯分布的双精度浮点型的值："+r.nextGaussian());
 }
 
}

一旦创建了对象实例，就可以调用 BigInteger 类中的一些方法进行运算操作，包括基本的数学运享和位运算以及一些取相反数、取绝对值等操作。下面列举了 BigInteger 类中常用的几种运算方法

public BigInteger add(BigInteger val): 做加法运算。

public BigInteger subtract(BigInteger va): 做减法运算

public BigInteger multiply(BigInteger val): 做乘法运算

public BigInteger divide(BigInteger val): 做除法运算。

public BigInteger remainder(BigInteger val): 做取余操作。

public BigInteger]] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中lt爱险法的商一个值为商，第二个值为余数。

public BigInteger pow(int exponent): 进行取参数的 exponent 次方操作。

public BigInteger negate0: 取相反数。

public BigInteger shifLef(int n): 将数字左移n位，如果n为负数，做右移操作

public BigInteger shiftRight(int n):将数字右移n位，如果n为负数，做左移操作

public BigInteger and(BigInteger val): 做与操作。

public BigInteger or(Biglnteger val): 做或操作。

public int compareTo(BigInteger val): 做数字比较操作。

public boolean equals(Object x): 当参数 x是 BigInteger 类型的数字并且数值与对象实例的数相等时，返回 true。

public BigInteger min(BigInteger val): 返回较小的数值。

public BigInteger max(BigInteger val): 返回较大的数值 。

例题11.12【使用BigInteger类进行数学运算】

import java.math.BigInteger;
public class BigIntegerDemo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //第一个大数字
  BigInteger b1 = new BigInteger("987654321987654321");
  //第二个大数字
  BigInteger b2 = new BigInteger("123456789123456789");
  //加法运算
  System.out.println("加法操作："+b1.add(b2));
  //减法运算
  System.out.println("减法操作："+b1.subtract(b2));
  //乘法运算
  System.out.println("乘法操作："+b1.multiply(b2));
  //除法运算
  System.out.println("除法操作："+b1.divide(b2));
  //取商运算
  System.out.println("取商："+b1.divideAndRemainder(b2)[0]);
  //取余运算
  System.out.println("取余数："+b1.divideAndRemainder(b2)[1]);
  //2次方运算
  System.out.println("做2次方操作："+b1.pow(2));
  //相反数运算
  System.out.println("取相反数操作："+b1.negate());
 }
 
}

在上述方法中，BigDecimal 类中 divide0方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义如下：

例题11.13【使用BigDecimal类进行数学运算】

import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalDemo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //第一个大小数
  BigDecimal b1 = new BigDecimal("0.00987654321987654321");
  //第二个大小数
  BigDecimal b2 = new BigDecimal("0.00123456789123456789");
  //加法运算
  System.out.println("两个数字相加结果："+b1.add(b2));
  //减法运算
  System.out.println("两个数字相减结果："+b1.subtract(b2));
  //乘法运算
  System.out.println("两个数字相乘结果："+b1.multiply(b2));
  //除法运算，商小数点后保留9位，并将结果进行四舍五入操作
  System.out.println("两个数字相除，保留小数点后9位结果："+b1.divide(b2,9,RoundingMode.HALF_UP));
  
  
  
 }
 
}

1.不会自动换行的print（)方法

 System.out.print("Hello!");

 2.可以自动换行的println()方法 

System.outprintln("书籍是人类进步的阶梯!");

例题11.14【查看执行一万次字符串拼接所消耗的时间】

public class SystemTimeDemo {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  long start = System.currentTimeMillis();//程序开始记录时间
  String str = null;//创建null字符串
  for(int i = 0;i<10000;i++) {//循环一万次
   str +=i;//字符串与循环变量拼接
  }
  long end = System.currentTimeMillis();//记录循环结束时间
  System.out.println("循环用时："+(end-start)+"毫秒");
 }
 
}

例题11.15【猜数字游戏】

import java.util.Random;
import java.util.Scanner;
public class ScannerDemo {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Random r = new Random();
  int num = r.nextInt(100);//从1~99取值
  int input = -1;//记录用户输入的值
  Scanner sc = new Scanner(System.in);//扫描器扫描控制台输入
  while(true) {
   System.out.println("猜一猜随机数是多少？");
   input = sc.nextInt();//获取用户输入的一个整数
   if(input>num) {//如果大于随机数
    System.out.println("你输入的数字大了！");
   }else if (input < num) {//如果小于随机数
    System.out.println("你输入的数字小了!");
   } else if (input == num) {//如果等于随机数
    break;//结束循环
   }else {
    System.out.println("您的输入有误!");
   }
  }
  System.out.println("恭喜你答对了!");
  sc.close();//关闭扫描器
 }
 
}

说明：
        由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getlnstance方法创建其对象外，还可以使用其子类创建对象，例如GregorianCalendar类。

 Calendar类提供的常用字段及说明如表9.15所示：

说明：
        从上面的表格中可以看到，add方法和roll方法都用来为给定的日历字段添加或减去指定的时间量，它们的主要区别在于使用add方法时会影响大的字段，像数学里加法的进位或错位，而使用roll方法设置的日期字段只是进行增加或减少，不会改变更大的字段。

例题11.19【让Java程序执行 Windows 系统的 help 命令】 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class RuntimeExecDemo {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Runtime r = Runtime.getRuntime();//获取本地Runtime对象
  try {
   Process p =r.exec("help");//执行help命令，获取进程对象
   InputStream is = p.getInputStream();//获取进程的字节输入流
   BufferedReader br = new BufferedReader(new InputStreamReader(is));
   String str = null;//创建null 字符串
   while((str = br.readLine()) != null) {//如果字符流中可以获取非空内容
    System.out.println(str);//打印获取的内容
   }
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

例题11.20【监控虚拟机内存使用情况】
 

public class MemoryDamo {
 
 public static void main(String[] args) {
  // TODO 自动生成的方法存根
  Runtime r=Runtime.getRuntime();//获取本地Runtime对免
  Integer ints[] = new Integer[10000];//创建长度为10000的整型
  long before = r.freeMemory();//获取当前空闲内存数
  System.out.println("赋值前空闲内存字节数:"+ before);
  for (int i = 0, length = ints.length; i < length; i++) {//循环为整型数组赋值
   ints[i]= i;//赋值
  }
  long after = r.freeMemory();//获取当前空闲内存数
  System.out.println("赋值后空闲内存字节数:"+after);
  System.out.println("数组用掉的内存字节数:"+(before- after));//输出数组用掉的内存量
 }
 
}