java notas de estudio 12: tipos de datos básicos de embalaje, la clase de matemáticas y la clase Random

En primer lugar, el embalaje de base de tipo de datos

tipos de datos básicos	En correspondencia con el embalaje
byte	Byte
corto	Corto
En t	Entero
largo	Largo
flotador	Flotador
doble	Doble
carbonizarse	Carbonizarse
booleano	Boole

1, clase de enteros se ajusta un valor en un int básicos Tipo de objeto. Objeto de tipo entero contiene un campo de tipo int.

1)、获取int 类型所表示的最大值和最小值
int minValue = Integer.MIN_VALUE;
int maxValue = Integer.MAX_VALUE;
2)、创建Integer对象
//Integer( int value)
//构造一个新分配的 Integer 对象，它表示指定的 int 值。
//Integer(String s)
//构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
int num=100;
Integer integer = new Integer(num);
System.out.println(integer);
String str="1000";
Integer integer1 = new Integer(str); //要一个字面上全是数字的字符串
System.out.println(integer1);

2, NumberFormatException digital formateada anormal
a. El tipo de cadena se convierte en el tipo de datos especificado, el tipo no se satisface cuando el tipo de cadena que se convierte, la excepción lanzada.
b. Cuando la conversión de una cadena en otros tipos, los espacios pueden primero ser retirados.
C. valores convert fuera del ámbito de la clase
D. valor nulo también pueden causar un error.
E. hexadecimal diferente.
3, la conversión de cadena numérica

public class MyDemo2 {
    public static void main(String[] args) {
        //(1)、数字-----字符串  100-----"100"
        int num=100;
        //方式1
        String str=num+"";
        //方式2
        String s = String.valueOf(num); //把数字转成字符串的静态方法
        //方式3
        String s1 = new Integer(num).toString();
        //(2)、字符串---数字   "100"--------100
        String str4="100";
        //方式1
        Integer integer = new Integer(str4);
        int i = integer.intValue();
       //方式2
        int parseInt = Integer.parseInt(str4);//静态方法，把字符串转成数字 记住这个方法
        System.out.println(parseInt);
        //(3)、转不同的进制
        String s2 = Integer.toBinaryString(100);//以二进制无符号整数形式返回一个整数参数的字符串表示形式。
        String s3 = Integer.toHexString(100);//以十六进制无符号整数形式返回一个整数参数的字符串表示形式。
        String s4 = Integer.toOctalString(100);//以八进制无符号整数形式返回一个整数参数的字符串表示形式。    
    }
}

4, el método de caracteres común

public class CharacterDemo {
  public static void main(String[] args) {
     Character c = Character.valueOf('c');
     String str = "abfdfAA102032";  
     //static boolean isUpperCase ( char ch)
     //确定指定字符是否为大写字母。
     //static boolean isSpaceChar ( char ch)
     //确定指定字符是否为 Unicode 空白字符。
     //static boolean isLowerCase ( char ch)
     //确定指定字符是否为小写字母。
     //static boolean isDigit ( char ch)
     //确定指定字符是否为数字。
     boolean a = Character.isUpperCase('a');
     System.out.println(a);
  }
}

5, desembalaje y embalaje
(1), caja de entrada manual

public class IntegerDemo2 {
    public static void main(String[] args) {
        //手动装箱
        int num=100;
        //方式1
        //Integer integer = new Integer(num);
        //方式2
        Integer integer = Integer.valueOf(num);
        Integer inter2 = Integer.valueOf("1000");
        //手动拆箱
        Integer integer4 = new Integer(100);
        int i = integer4.intValue();
        System.out.println(i+10);
    }
 }

cuadro de entrada (2) automático

public class IntegerDemo {
    public static void main(String[] args) {
        //JDK1.5 之后 引入了自动拆装箱的机制
        //自动装箱：将基本类型自动包装成对应的引用类型
        //自动拆箱：将包装类型自动转成对应的基本类型
        //int num=100;
        Integer a=100; //自动装箱
        Integer b=200;// 自动装箱
        int sum=a+b;//自动拆箱
        System.out.println("---------------------");
        Integer c=10; //自动装箱
        c+=20;//自动拆箱 自动装箱
    }
}

Dos, la clase de Matemáticas
A, visión general: clase Math contiene métodos para realizar operaciones matemáticas básicas, como, logarítmicas, funciones trigonométricas y exponenciales jamás raíz cuadrada.
B, variables miembro

• public static final de doble E: Número de base natural
• pública PI doble static final: pi

C, métodos miembro

• static int abs (int a) el valor público absoluto
• ceil doble static (doble a) 向上 取 整
• doble suelo static (doble a) redondea hacia abajo
• int public static max (int a, int b) obtener un valor máximo
• int public static min (int a, int b) obtener el valor mínimo
• public static doble pow (doble a, doble b) obtención de una potencia de b
• public static doble aleatorio () devuelve un doble valor de adquisición de números aleatorios con un signo positivo, que es mayor que o igual a 0,0 y menor que 1,0.
• public static int redonda (float a) el redondeo
• double sqrt static (doble a) obtener una raíz cuadrada positiva

Ejemplo D, utilizando la clase Math

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.E);
        //常用的静态方法
        double num = Math.random();    
        System.out.println(Math.abs(-1));
        System.out.println(Math.ceil(3.14));
        System.out.println(Math.floor(3.14));
        System.out.println(Math.max(19, Math.max(1, 10)));
        System.out.println(Math.min(1,90));
        System.out.println(Math.pow(2,3));
        System.out.println(Math.round(6.59));//拿小数点后面第一个数来舍入
        System.out.println(Math.sqrt(4));
        System.out.println(Math.pow(8.0, 1.0/3.0)); //求一个数的立方根
        double sin = Math.sin(Math.PI / 2.0);
        System.out.println(sin);
    }
}

Tres, Random clase
A, visión general de: generar un número aleatorio si se utiliza la clase para crear dos idénticos con el ejemplo de la semilla aleatoria, cada instancia de la misma secuencia de llamadas de método, que generará y devolver la misma secuencia de números.
B, constructor

• pública aleatoria () no se da semilla, utilizando milisegundos (el sistema actual) por defecto
• pública aleatorio (largo semilla) mucho un tipo dado de las semillas, después de un número aleatorio generado dado cada vez es la misma.

C: método miembro

• int público nextInt () // ningún parámetro aleatorio rango de números representa el rango de tipo int
• public int nextInt (int n) // puede especificar un rango de números aleatorios

D: Ejemplos de uso de la clase Random

public class RandomDemo {
    public static void main(String[] args) {
        //创建随机类
        Random random = new Random();
        for (int i = 0; i < 1000; i++) {
           // int num= random.nextInt(); 不指定随机整数的范围，生成的数在int类型的范围内
            int num = random.nextInt(10);  //随机数的范围 大于等于 0 小于 10
            boolean b = random.nextBoolean();
            double v = random.nextDouble();
            System.out.println(num);
            System.out.println(b);
            System.out.println(v);
        }
    }
}