做投融资平台的网站都有哪些?,中国医院考试网站模板下载,轻量wordpress主题,贵阳平台网站建设文章目录包装类包装类层次结构基本类型包装类特殊包装类数组一维数组多维数组可变长参数字符串String类StringBuilder类内部类成员内部类静态内部类局部内部类匿名内部类Lambda表达式方法引用异常机制自定义异常抛出异常异常的处理常用工具类数学工具类随机数数组工具类包装类 …
文章目录包装类包装类层次结构基本类型包装类特殊包装类数组一维数组多维数组可变长参数字符串String类StringBuilder类内部类成员内部类静态内部类局部内部类匿名内部类Lambda表达式方法引用异常机制自定义异常抛出异常异常的处理常用工具类数学工具类随机数数组工具类包装类
包装类层次结构 基本类型包装类
package com.test.entity;
public class Main {public static void main(String[] args) {Integer a new Integer(10);Integer b new Integer(10);System.out.println(a b);}
}public static void main(String[] args) {Integer a 10, b 10;System.out.println(a b);
}package com.test.entity;
public class Main {public static void main(String[] args) {Integer a 128, b 128;System.out.println(a b);}
}public static Integer valueOf(int i) {if (i IntegerCache.low i IntegerCache.high) //这里会有一个IntegerCache如果在范围内那么会直接返回已经提前创建好的对象return IntegerCache.cache[i (-IntegerCache.low)];return new Integer(i);
}false true false IntegerCache会默认缓存-128~127之间的所有值将这些值提前做成包装类放在数组中存放 package com.test.entity;
public class Main {public static void main(String[] args) {Integer i Integer.valueOf(5555);System.out.println(i);Integer j Integer.parseInt(5555);System.out.println(j);}
}package com.test.entity;
public class Main {public static void main(String[] args) {Integer i Integer.decode(036);System.out.println(i);System.out.println(Integer.toHexString(166));}
}30 a6 特殊包装类
package com.test.entity;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
public class Main {public static void main(String[] args) {BigDecimal i BigDecimal.valueOf(10);i i.divide(BigDecimal.valueOf(3), 100, RoundingMode.CEILING);//计算10/3的结果精确到小数点后100位//RoundingMode是舍入模式就是精确到最后一位时该怎么处理这里CEILING表示向上取整System.out.println(i);BigInteger j BigInteger.valueOf(Long.MAX_VALUE);j j.pow(100); //来个100次方吧System.out.println(j);}
}数组
一维数组
package com.test.entity;
public class Main {public static void main(String[] args) {int[] array new int[]{1,2,43,5};for (int i 0; i array.length; i) {System.out.print(array[i] );}System.out.println();//foreachfor (int a:array){System.out.print(a );}}
}public static void main(String[] args) {String[] arr new String[10];Object[] array arr; //引用类型的数组同样支持向上转型Object[] arr new Object[10];String[] array (String[]) arr; //引用类型数组也支持向下转型
}多维数组
package com.test.entity;
public class Main
{public static void main(String[] args){int[][] arr new int[][]{{1, 2}, {3, 4}, {5, 6}};for (int i 0; i arr.length; i){ //要遍历一个二维数组那么我们得一列一列一行一行地来for (int j 0; j arr[0].length; j){System.out.print(arr[i][j] );}System.out.println();}}
}可变长参数
package com.test.entity;
public class Main
{public static void main(String[] args){test(co,le,ak,66);}public static void test(String... strings){ //strings这个变量就是一个String[]类型的for (String string : strings) {System.out.print(string); //遍历打印数组中每一个元素}}
}字符串
String类
package com.test.entity;
public class Main
{public static void main(String[] args) {String str1 Hello World;String str2 Hello World;System.out.println(str1 str2);}
}直接使用双引号创建的字符串如果内容相同为了优化效率那么始终都是同一个对象 package com.test.entity;
public class Main
{public static void main(String[] args) {String str1 new String(Hello World);String str2 new String(Hello World);System.out.println(str1 str2);System.out.println(str1.equals(str2)); //字符串的内容比较一定要用equals}
}false true package com.test.entity;
public class Main
{public static void main(String[] args) {String str Hello World;String[] strings str.split( );for (String string : strings){System.out.println(string);}String sub str.substring(6, 8); //分割字符串返回新的子串对象,这里返回67字符System.out.println(sub);}
}Hello World Wo package com.test.entity;
public class Main
{public static void main(String[] args){String str Hello World;char[] chars str.toCharArray();for (char aChar : chars){System.out.println(aChar);}char[] chars2 new char[]{c, o, l};String str2 new String(chars2);System.out.println(str2);}
}StringBuilder类
package com.test.entity;
public class Main
{public static void main(String[] args) {StringBuilder builder new StringBuilder(); //一开始创建时内部什么都没有builder.append(AAA); //我们可以使用append方法来讲字符串拼接到后面builder.append(BBB);System.out.println(builder); //当我们字符串编辑完成之后就可以使用toString转换为字符串了builder.delete(2, 5); //删除234这个范围内的字符System.out.println(builder.toString());}
}AAABBB AAB 内部类
成员内部类
package com.test.entity;
public class Main
{public static void main(String[] args) {Test a new Test(小明);Test.Inner inner a.new Inner(); //依附于a创建的对象那么就是a的inner.test(coleak);}
}package com.test.entity;
public class Test {private final String name;public Test(String name){this.name name;}public class Inner {String name;public void test(String name){System.out.println(方法参数的name name); //就近原则System.out.println(成员内部类的name this.name); //表示内部类对象System.out.println(成员内部类的name Test.this.name);//如果需要指定为外部的对象那么需要在前面添加外部类型名称}}
}方法参数的name coleak 成员内部类的name null 成员内部类的name 小明 静态内部类
package com.test.entity;
public class Test {private final String name;public Test(String name){this.name name;}public static class Inner {public void test(){System.out.println(我是静态内部类);}}
}package com.test.entity;
public class Main
{public static void main(String[] args) {Test.Inner inner new Test.Inner();inner.test();}
}仅使用静态内部类时不会加载外部类而是直接加载内部类完成内部静态类的初始化和构造方法 局部内部类
public class Test {public void hello(){class Inner{ //局部内部类跟局部变量一样先声明后使用public void test(){System.out.println(我是局部内部类);}}Inner inner new Inner(); //局部内部类直接使用类名就行inner.test();}
}匿名内部类
public class Main {public static void main(String[] args) {
// Student student new Student(); //抽象类和接口均无法实例化
// student.test();}
}public abstract class Student {public abstract void test();protected String acoleak;
}public class Main {public static void main(String[] args) {Student student new Student() {int b;Overridepublic void test() {System.out.println(a);System.out.println(我是匿名内部类的实现!);}};student.test();}
}coleak 我是匿名内部类的实现! Lambda表达式 如果一个接口中有且只有一个待实现的抽象方法那么我们可以将匿名内部类简写为Lambda表达式 package com.test.entity;
public interface Study {String stu(String str);static int num10;
}import com.test.entity.Study;
public class Main
{public static void main(String[] args){Study study (a) -{System.out.println(Study.num);return 我是学习方法! a;};System.out.println(study.stu(coleak));}
}10 我是学习方法! coleak 方法引用
package com.test.entity;public interface Study {int sum(int a, int b);
}import com.test.entity.Study;
public class Main {public static void main(String[] args) {//Study study (a, b) - a b;Study study (a, b) - Integer.sum(a, b); //直接使用Integer提供求和方法System.out.println(study.sum(10, 20));}
}public static void main(String[] args) {Study study Integer::sum; //双冒号来进行方法引用静态方法使用 类名::方法名 的形式System.out.println(study.sum(10, 20));
}public static int sum(int a, int b) {return a b;
}public static void main(String[] args){Main main new Main();Study study String::new;}异常机制
自定义异常 异常两大类编译时异常运行时异常 抛出异常 当别人调用我们的方法时如果传入了错误的参数导致程序无法正常运行这时我们就可以手动抛出一个异常来终止程序继续运行下去同时告知上一级方法执行出现了问题。 我们在重写方法时如果父类中的方法表明了会抛出某个异常只要重写的内容中不会抛出对应的异常我们可以直接省去 public class Main
{public static void main(String[] args) throws Exception {System.out.println(test(30,4));System.out.println(test(30,0));System.out.println(coleak);}public static int test(int a, int b) throws Exception{if(b 0)throw new RuntimeException(被除数不能为0); //使用throw关键字来抛出异常return a / b;}
}异常的处理
public class Main
{public static void main(String[] args) {try { //使用try-catch语句进行异常捕获Object object null;object.toString();} catch (NullPointerException e){e.printStackTrace(); //打印栈追踪信息System.out.println(异常错误信息e.getMessage()); //获取异常的错误信息}System.out.println(程序继续正常运行);}
}
import java.io.IOException;public class Main
{public static void main(String[] args) throws IOException {test(10); //必须要进行异常的捕获否则报错}private static void test(int a) throws IOException { //明确会抛出IOExceptionthrow new IOException();}
}如果已经是主方法了那么就相当于到顶层了此时发生异常再往上抛出的话就会直接交给JVM进行处理默认会让整个程序终止并打印栈追踪信息。 import java.io.IOException;
public class Main
{public static void main(String[] args) throws IOException {try {int[] arr new int[1];arr[1] 100; //这里发生的是数组越界异常它是运行时异常的子类} catch (RuntimeException e){ //使用运行时异常同样可以捕获到System.out.println(捕获到异常);}}
}如果我们要捕获的异常是某个异常的父类那么当发生这个异常时同样可以捕获到 try {//....
}
catch (NullPointerException e){}
catch (IndexOutOfBoundsException e){}
catch (RuntimeException e){}try {//....
} catch (NullPointerException | IndexOutOfBoundsException e) { //用|隔开每种类型即可
}当代码可能出现多种类型的异常时我们希望能够分不同情况处理不同类型的异常就可以使用多重异常捕获 try {//....
}catch (Exception e){}finally {System.out.println(lbwnb); //无论是否出现异常都会在最后执行
}无论是否出现异常都会在最后执行任务可以交给finally语句块来处理 try语句块至少要配合catch或finally中的一个 常用工具类
数学工具类
import java.io.IOException;
public class Main
{public static void main(String[] args) {//Math也是java.lang包下的类所以说默认就可以直接使用System.out.println(Math.pow(5, 3.5)); //我们可以使用pow方法直接计算a的b次方Math.abs(-1); //abs方法可以求绝对值Math.max(19, 20); //快速取最大值Math.min(2, 4); //快速取最小值System.out.println(Math.sqrt(9)); //求一个数的算术平方根}
}import java.io.IOException;
public class Main
{public static void main(String[] args) {Math.sin(Math.PI / 2); //求π/2的正弦值这里我们可以使用预置的PI进行计算Math.cos(Math.PI); //求π的余弦值Math.tan(Math.PI / 4); //求π/4的正切值System.out.println(Math.asin(1)); //求arcsin1的值Math.acos(1);Math.atan(0);}
}public static void main(String[] args) {Math.log(Math.E); //e为底的对数函数其实就是ln我们可以直接使用Math中定义好的eMath.log10(100); //10为底的对数函数//利用换底公式我们可以弄出来任何我们想求的对数函数double a Math.log(4) / Math.log(2); //这里是求以2为底4的对数log(2)4 ln4 / ln2System.out.println(a);
}import java.io.IOException;
public class Main
{public static void main(String[] args) {System.out.println(Math.log(Math.E)); //e为底的对数函数其实就是ln我们可以直接使用Math中定义好的eSystem.out.println(Math.log10(100)); //10为底的对数函数//利用换底公式我们可以弄出来任何我们想求的对数函数double a Math.log(4) / Math.log(2); //这里是求以2为底4的对数log(2)4 ln4 / ln2System.out.println(a);}} 1.0 2.0 2.0 随机数
import java.util.Random;
public class Main
{public static void main(String[] args) {Random random new Random(); //创建Random对象for (int i 0; i 30; i) {System.out.print(random.nextInt(100) ); //nextInt方法可以指定创建0 - x之内的随机数}}}
数组工具类
import java.util.Arrays;
public class Main {public static void main(String[] args) {int[] arr new int[]{1, 4, 5, 8, 2, 0, 9, 7, 3, 6};System.out.println(Arrays.toString(arr));Arrays.sort(arr); //可以对数组进行排序将所有的元素按照从小到大的顺序排放System.out.println(Arrays.toString(arr));int[] arr2 new int[10];Arrays.fill(arr2, 66);System.out.println(Arrays.toString(arr2));int[] target Arrays.copyOf(arr, 10);System.out.println(Arrays.toString(target)); //拷贝数组的全部内容并生成一个新的数组对象System.out.println(arr target);int[] target2 Arrays.copyOfRange(arr, 3, 5); //也可以只拷贝某个范围内的内容System.out.println(Arrays.toString(target2));int[] target3 new int[10];System.arraycopy(arr, 2, target3, 4, 5); //使用System.arraycopy进行搬运System.out.println(Arrays.toString(target3));System.out.println(Arrays.binarySearch(target3, 5));int[][] array new int[][]{{2, 8, 4, 1}, {9, 2, 0, 3}};System.out.println(Arrays.deepToString(array));int[][] a new int[][]{{2, 8, 4, 1}, {9, 2, 0, 3}};int[][] b new int[][]{{2, 8, 4, 1}, {9, 2, 0, 3}};System.out.println(Arrays.equals(a, b)); //equals仅适用于一维数组System.out.println(Arrays.deepEquals(a, b));}
} [1, 4, 5, 8, 2, 0, 9, 7, 3, 6] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [66, 66, 66, 66, 66, 66, 66, 66, 66, 66] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] false [3, 4] [0, 0, 0, 0, 2, 3, 4, 5, 6, 0] 7 [[2, 8, 4, 1], [9, 2, 0, 3]] false true
