java将select和from之间的字段获取 java select()

转载

Aceryt 2024-02-04 10:49:46

文章标签 java System 二分查找数组 文章分类 Java 后端开发

JavaSE

选择排序

选择排序概述
选择排序图解
选择排序代码实现

二分查找

普通查找和二分查找

普通查找
二分查找

二分查找图解
二分查找代码实现

异常

异常概念
异常体系
异常分类
异常的产生过程解析

异常的产生和处理

异常的产生

throw关键字的作用
throw关键字的使用格式
示例代码

声明处理异常

声明处理异常的概述
声明处理异常格式
示例代码

捕获处理异常try…catch

捕获处理异常的概述
捕获处理异常格式
获取异常信息

finally 代码块

finally代码块的概述
finally代码块的语法格式
示例代码

异常注意事项

自定义异常

自定义异常概述

为什么需要自定义异常类:
什么是自定义异常类:
异常类如何定义:

自定义异常的示例

选择排序

选择排序概述

另外一种排序的方式，选中数组的某个元素,其后面的元素依次和选中的元素进行两两比较，将较大的数据放在后面，依次从前到后选中每个元素，直至所有数据按要求完成排序
如果有n个数据进行排序，总共需要比较n-1轮
每一轮比较完毕，下一轮的比较就会少一个数据参与

选择排序图解

java将select和from之间的字段获取 java select()_java

选择排序代码实现

public class Demo {
    public static void main(String[] args) {
        int[] arr = {45,25,35,55,15};
        // 选择排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i+1;j<arr.length;j++){
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("排序之后的数组:"+ Arrays.toString(arr));// 排序之后的数组:[15, 25, 35, 45, 55]
    }
}

二分查找

普通查找和二分查找

普通查找

原理：遍历数组，获取每一个元素，然后判断当前遍历的元素是否和要查找的元素相同，如果相同就返回该元素的索引。如果没有找到，就返回一个负数作为标识(一般是-1)

二分查找

原理: 每一次都去获取数组的中间索引所对应的元素，然后和要查找的元素进行比对，如果相同就返回索引；如果不相同，就比较中间元素和要查找的元素的值；如果中间元素的值大于要查找的元素，说明要查找的元素在左侧，那么就从左侧按照上述思想继续查询(忽略右侧数据)；如果中间元素的值小于要查找的元素，说明要查找的元素在右侧，那么就从右侧按照上述思想继续查询(忽略左侧数据)；
二分查找对数组是有要求的,数组必须已经排好序

二分查找图解

假设有一个给定有序数组(10,14,21,38,45,47,53,81,87,99),要查找50出现的索引

则查询过程如下图所示:

java将select和from之间的字段获取 java select()_二分查找_02

二分查找代码实现

public static void main(String[] args) {
        int[] arr = {10, 14, 21, 38, 45, 47, 53, 81, 87, 99};
        int index = binarySerach(arr, 38);
        System.out.println(index);
	}
	/**
     * 二分查找方法
     * @param arr 查找的目标数组
     * @param number 查找的目标值
     * @return 找到的索引,如果没有找到返回-1
     */
    public static int binarySerach(int[] arr, int number) {
        int start = 0;
        int end = arr.length - 1;

        while (start <= end) {
            int mid = (start + end) / 2;
            if (number == arr[mid]) {
                return mid ;
            } else if (number < arr[mid]) {
                end = mid - 1;
            } else if (number > arr[mid]) {
                start = mid + 1;
            }
        }
        return -1;  //如果数组中有这个元素，则返回
    }

异常

异常概念

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

注意: 在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

异常体系

异常机制其实是帮助找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

java将select和from之间的字段获取 java select()_数组_03

Throwable体系：

Error：严重错误Error，无法通过处理的错误，只能事先避免。
Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

异常分类

平常说的异常就是指Exception，因为这类异常一旦出现，就要对代码进行更正，修复程序。
异常(Exception)的分类：根据在编译时期还是运行时期去检查异常?

编译时期异常：checked异常。在编译时期，就会检查，如果没有处理异常，则编译失败。(如日期格式化异常)
运行时期异常：runtime异常。在运行时期，检查异常。在编译时期，运行异常不会编译器检测(不报错)。(如数学异常)

异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。通过图解来解析下异常产生的过程。

工具类

public class ArrayTools {
    // 对给定的数组通过给定的角标获取元素。
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}

测试类

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = { 34, 12, 67 };
        intnum = ArrayTools.getElement(arr, 4)
        System.out.println("num=" + num);
        System.out.println("over");
    }
}

上述程序执行过程图解：

java将select和from之间的字段获取 java select()_System_04

异常的产生和处理

异常的产生

throw关键字的作用

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

throw关键字的使用格式

throw new 异常类名(参数);

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

示例代码

public class Student {
    //姓名
    private String name;
    //年龄
    private int age;

    //构造方法
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        //对年龄的判断
        if(age >= 0) {
            this.age = age;
        }else{
            //如果年龄是负数,就让他报错
            throw new RuntimeException("年龄不能是" + age);
        }
    }
    //set get
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //对年龄的判断
        if(age >= 0) {
            this.age = age;
        }else{
            //如果年龄是负数,就让他报错
            throw new RuntimeException("年龄不能是" + age);
        }
    }

    //toString
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //正常情况下,年龄不可能是一个负数
        //要求：赋值正数正常赋值,赋值负数就让代码报错！

        //创建对象
        Student s = new Student("小明",18);
        System.out.println(s);

        //创建对象
        Student s2 = new Student();
        s2.setName("小红");
        s2.setAge(-20);
        System.out.println(s2);
    }
}

声明处理异常

声明处理异常的概述

声明处理异常：使用throws关键字将问题标识出来, 表示当前方法不处理异常，而是提醒给调用者, 让调用者来处理…最终会到虚拟机,虚拟机直接结束程序,打印异常信息。

声明处理异常格式

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{  // 可以抛出一个,也可以多个
}

示例代码

public class Demo {
    public static void main(String[] args) throws IOException{
        method1();
    }

    public static void method3(int num) throws Exception {
        if(num == 1) {
            throw new IOException("IO异常");// 创建了一个编译异常,并通过throw抛出这个编译异常
        }else{
            throw new ParseException("解析异常",1);
        }
    }

    public static void method2(int num) throws IOException,ParseException{
        if(num == 1) {
            throw new IOException("IO异常");// 创建了一个编译异常,并通过throw抛出这个编译异常
        }else{
            throw new ParseException("解析异常",1);
        }   

    public static void method1() throws IOException{
        throw new IOException("IO异常");// 创建了一个编译异常,并通过throw抛出这个编译异常
    }
}

捕获处理异常try…catch

捕获处理异常的概述

捕获处理异常：对异常进行捕获处理 , 处理完后程序可以正常向下执行。

捕获处理异常格式

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
执行步骤:
	1.首先执行try中的代码,如果try中的代码出现了异常,那么就直接执行catch()里面的代码,执行完后,程序继续往下执行
    2.如果try中的代码没有出现异常,那么就不会执行catch()里面的代码,而是继续往下执行

注意:
try和catch都不能单独使用,必须连用
try中的代码出现了异常,那么出现异常位置后面的代码就不会再执行了
捕获处理异常,如果程序出现了异常,程序会继续往下执行
声明处理异常,如果程序出现了异常,程序就不会继续往下执行
示例代码：

public class Demo {
    public static void main(String[] args) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse("1999年10月12日");
            System.out.println(date);
        }catch (Exception e){
            System.out.println("出现了异常....");
        }
        System.out.println("结束");
    }
}

获取异常信息

Throwable类中定义了一些查看方法:

public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

finally 代码块

finally代码块的概述

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

finally代码块的语法格式

try{
    可能会出现异常的代码
}catch(异常的类型 变量名){
    处理异常的代码或者打印异常的信息
}finally{
    无论异常是否发生,都会执行这里的代码(正常情况,都会执行finally中的代码,一般用来释放资源)
}

执行步骤:
 1.首先执行try中的代码,如果try中的代码出现了异常,那么就直接执行catch()里面的代码,执行完后会执行finally中的代码,然后程序继续往下执行
 2.如果try中的代码没有出现异常,那么就不会执行catch()里面的代码,但是还是会执行finally中的代码,然后程序继续往下执行

注意:finally不能单独使用。

示例代码

public class Demo {
    public static void main(String[] args) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse("1999年10月12日");
            System.out.println(date);
        }catch (Exception e){
            System.out.println("出现了异常....");
        }finally {
            System.out.println("finally中的代码...");
        }
        System.out.println("结束");
        System.out.println("==================================");
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse("1999-10-12");
            System.out.println(date);
        }catch (Exception e){
            System.out.println("出现了异常....");
        }finally {
            System.out.println("finally中的代码...");
        }
        System.out.println("结束");
    }
}

当只有在try或者catch中调用退出JVM的相关方法，此时finally才不会执行，否则finally永远会执行。

异常注意事项

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子集。
父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
当多异常分别处理时，捕获处理，前边的类不能是后边类的父类
在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。
多个异常使用捕获又该如何处理呢？
1.多个异常分别处理。
2.多个异常一次捕获，多次处理。
3.多个异常一次捕获一次处理。
一般我们是使用一次捕获多次处理方式，格式如下：

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

代码如下:

public class Demo {
    public static void main(String[] args) {
		System.out.println(1/0);
    }

    /**
     * 多个异常一次捕获一次处理
     * @param num
     */
    public static void method3(int num) {
        try {
            if(num == 1) {
                throw new IOException("IO异常");
            }else{
                throw new ParseException("解析异常",1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 多个异常一次捕获，多次处理。
     * @param num
     */
    public static void method2(int num) {
        try {
            if(num == 1) {
                throw new IOException("IO异常");
            }else{
                throw new ParseException("解析异常",1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    /**
     * 多个异常分别处理。
     * @param num
     */
    public static void method1(int num) {
        if(num == 1) {
            try {
                throw new IOException("IO异常");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            try {
                throw new ParseException("解析异常",1);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
}

自定义异常

自定义异常概述

为什么需要自定义异常类:

Java中不同的异常类，分别表示着某一种具体的异常情况，那么在开发中总是有些异常情况是SUN没有定义好的，例如年龄负数问题，考试成绩负数问题。这些异常在JDK中没有定义过，此时根据自己业务的异常情况来定义异常类。

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类。
自定义一个业务逻辑异常：RegisterException。一个注册异常类。

异常类如何定义:

自定义一个编译期异常：自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类：自定义类并继承于java.lang.RuntimeException。

自定义异常的示例

要求：模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个注册异常类RegisterException：

// 业务逻辑异常
public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

public class Demo {
    // 模拟数据库中已存在账号
    private static String[] names = {"bill","hill","jill"};
   
    public static void main(String[] args) {     
        //调用方法
        try{
              // 可能出现异常的代码
            checkUsername("nill");
            System.out.println("注册成功");//如果没有异常就是注册成功
        }catch(LoginException e){
            //处理异常
            e.printStackTrace();
        }
    }

    //判断当前注册账号是否存在
    //因为是编译期异常，又想调用者去处理 所以声明该异常
    public static boolean checkUsername(String uname) throws LoginException{
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new LoginException("亲"+name+"已经被注册了！");
            }
        }
        return true;
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：sql server 列宽 sqlplus 设置列宽度

下一篇：redisson中加入线程阻塞 watchdog怎么停 redis线程锁

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯