第四章多线程/1-3/05/1-异常-1_7_1_06到1_7_1_14////20190623修改

最新推荐文章于 2022-04-06 20:41:05 发布
最新推荐文章于 2022-04-06 20:41:05 发布
阅读量148 收藏
点赞数
分类专栏： 黑马JAVA培训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34318539/article/details/93380974
版权

目录

1_7_1_06_throws关键字_异常处理的第一种方法

1_7_1_07_try_catch_异常处理的第二种方式 

1_7_1_08_Throwable类中3个异常处理的方法

1_7_1_09_finally代码块

1_7_1_10_异常注意事项_多异常的捕获处理

1_7_1_11_异常注意事项_finally有return语句

1_7_1_12_异常注意事项_子父类异常【没看到实际价值啊】

1_7_1_13_自定义异常类-注册异常的类

1_7_1_14_自定义异常类的练习

 

1_7_1_06_throws关键字_异常处理的第一种方法

代码位置 E:\0-2019黑马\1.Java基础笔记\16.【异常、线程】-笔记\code\05_ExceptionAndThread\src\com\itheima\demo01\Exception

 throws关键字:异常处理的第一种方式,交给别人处理

    作用:

        当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象

        可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理

    使用格式:在方法声明时使用

        修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{

            throw new AAAExcepiton("产生原因");

            throw new BBBExcepiton("产生原因");

            ...

        }

     注意:

        1.throws关键字必须写在方法声明处

        2.throws关键字后边声明的异常必须是Exception或者是Exception的子类

        3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常

            如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可

        4.调用了一个声明抛出异常的方法,我们就必须的处理声明的异常

            要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM

            要么try...catch自己处理异常

 编程序：

    定义一个方法,对传递的文件路径进行合法性判断

        如果路径不是"c:\\a.txt",那么我们就抛出文件找不到异常对象,告知方法的调用者

        注意:

            FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常

            可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理

 注意下面代码中的 throw new FileNotFoundException("文件路径不是c:\\a.txt");

import java.io.FileNotFoundException;
public class Hello{
        public static void main(String args[])throws FileNotFoundException{
                readFile("C:\\Users\\renxianshou\\Desktop\\a.txt");
        }
        public static void readFile(String fileName)throws FileNotFoundException{
                if(!fileName.equals("C:\\Users\\renxianshou\\Desktop\\a.txt")){
                        throw new FileNotFoundException("文件路径不是c:\\a.txt");
                }
                else
                        System.out.print("yes");
        }
}

3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常

import java.io.FileNotFoundException;
import java.io.IOException;
public class Hello{
        public static void main(String args[])throws FileNotFoundException,IOException{
                readFile("C:\\Users\\renxianshou\\Desktop\\a.txt");
        }
        public static void readFile(String fileName)throws FileNotFoundException,IOException{
                if(!fileName.equals("C:\\Users\\renxianshou\\Desktop\\a.txt")){
                        throw new FileNotFoundException("文件路径不是c:\\a.txt");
                }
                if(!fileName.endsWith(".txt")){
                        throw new IOException("文件后缀名不对");
                }
                else
                        System.out.print("yes");
        }
}

1_7_1_07_try_catch_异常处理的第二种方式 

E:\0-2019黑马\1.Java基础笔记\16.【异常、线程】-笔记\code\05_ExceptionAndThread\src\com\itheima\demo02\Exception

 throws代码有缺陷,不能执行出现了异常后面的代码 

try...catch:异常处理的第二种方式,自己处理异常

    格式:

        try{

            可能产生异常的代码

        }catch(定义一个异常的变量,用来接收try中抛出的异常对象){

            异常的处理逻辑,异常对象之后,怎么处理异常对象

            一般在工作中,会把异常的信息记录到一个日志中

        }

        ...

        catch(异常类名 变量名){

        }

    注意:

        1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象

        2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,将继续执行try...catch之后的代码

        3.如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码

 判断后缀名

import java.io.IOException;
public class Demo01Runnable {
    public static void main(String[] args) {
        try{
            //可能产生异常的代码
            readFile("C:\\Users\\renxianshou\\Desktop\\a.txt");
            System.out.println("资源释放");
        }catch (IOException e){//try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
            e.printStackTrace();
        }
        System.out.println("后续代码");
    }
  
    public static void readFile(String fileName) throws IOException {
//    	if(!fileName.equals("a.txt")){
//    		throw new IOException("文件的名称不对");
//    	}
		if(!fileName.endsWith(".txt")){
			throw new IOException("文件的后缀名不对");
		    }
		System.out.println("路径没有问题,读取文件");
	}
}

 在输出中可以看到可以执行后续代码，即输出System.out.println("后续代码");

1_7_1_08_Throwable类中3个异常处理的方法

异常的处理方法

  1. String getMessage() 返回此throwable的简短描述
  2. String toString()返回此throwable的详细消息字符串
  3. void printStackTrace() 打印很全面的异常信息
import java.io.IOException;
public class Hello {
    public static void main(String[] args) {
        try{
            //可能产生异常的代码
            readFile("c:\\a.tx");
            System.out.println("资源释放");
        }catch (IOException e){//try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
			//System.out.println(e.getMessage());//文件的后缀名不对
			//System.out.println(e.toString());//重写Object类的toString java.io.IOException: 文件的后缀名不对
			//System.out.println(e);//java.io.IOException: 文件的后缀名不对
			e.printStackTrace();
        }
        System.out.println("后续代码");
    }
    public static void readFile(String fileName) throws IOException {
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }
}

1_7_1_09_finally代码块

  finally代码块

     格式:

        try{

            可能产生异常的代码

        }catch(定义一个异常的变量,用来接收try中抛出的异常对象){     //catch (IOException e) {

            异常的处理逻辑,异常异常对象之后,怎么处理异常对象

            一般在工作中,会把异常的信息记录到一个日志中

        }

        ...

        catch(异常类名 变量名){  //catch (IOException e) {

        }finally{

            无论是否出现异常   finally语句都会执行

        }

     注意:

        1.finally不能单独使用,必须和try一起使用 

        2.finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)

import java.io.IOException;
public class Hello {
    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            readFile("c:\\a.txt");
        } catch (IOException e) {
            //异常的处理逻辑
            e.printStackTrace();
        } finally {
            //无论是否出现异常,都会执行
            System.out.println("必须执行的资源释放代码");
        }
    }
    public static void readFile(String fileName) throws IOException {
    	if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        } 
		System.out.println("路径没有问题,读取文件");
    }
}

 

1_7_1_10_异常注意事项_多异常的捕获处理

多个异常使用捕获又该如何处理呢？

1. 多个异常分别处理。try-catch;try-catch;try-catch;

2. 多个异常一次捕获，多次处理。try-catch-catch-catch

3. 多个异常一次捕获一次处理。try----catch

代码；报错了，不知原因

import java.util.List;
import java.util.*;
/*
    异常的注意事项
 */
public class Hello {
    public static void main(String[] args) {
        /*
            多个异常使用捕获又该如何处理呢？
            1. 多个异常分别处理。
            2. 多个异常一次捕获，多次处理。
            3. 多个异常一次捕获一次处理。
         */

        //1. 多个异常分别处理。
       /* try {
            int[] arr = {1,2,3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }

        try{
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }*/

        //2. 多个异常一次捕获，多次处理。
        /*try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }*/

        /*
            一个try多个catch注意事项:
                catch里边定义的异常变量,如果有子父类关系,那么子类的异常变量必须写在上边,否则就会报错
                ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
         */
        /*try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }*/

        //3. 多个异常一次捕获一次处理。
        /*try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (Exception e){
            System.out.println(e);
        }*/

        //运行时异常被抛出可以不处理。即不捕获也不声明抛出。
        //默认给虚拟机处理,终止程序,什么时候不抛出运行时异常了,在来继续执行程序
        int[] arr = {1,2,3};
        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        List<Integer> list = List.of(1, 2, 3);
        System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        System.out.println("后续代码!");
    }
}

1_7_1_11_异常注意事项_finally有return语句

 如果finally有return语句,永远返回finally中的结果,要避免该情况.要避免该情况.要避免该情况.要避免该情况.

public class Hello {
    public static void main(String[] args) {
        int a = getA();
        System.out.println(a);
    }

    //定义一个方法,返回变量a的值
    public static int getA(){
        int a = 10;
//在这里定义a=10
        try{
            return a;
        }catch (Exception e){
            System.out.println(e);
        }finally {
            //一定会执行的代码
            a = 100;
  //finally 语句一定执行，因为有ruturn a ;所以结果为 a=100
          return a;
        }

    }
}

finally中的语句一定会执行。finally中要避免使用return语句。

1_7_1_12_异常注意事项_子父类异常【没看到实际价值啊】

子父类的异常:

        - 如果父类抛出了多个异常, 子类重写父类方法时,会抛出和父类相同的异常   或者是父类异常的子类  或者不抛出异常。

        - 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。如果此时子类产生该异常，只能捕获处理，不能声明抛出

    注意:本小节重点是  父类异常是什么样,子类异常就是什么样

 

public class Hello {
    public void show01() throws NullPointerException,ClassCastException{}//子类；多个异常
    public void show02() throws IndexOutOfBoundsException{}//子类；
    public void show03() throws IndexOutOfBoundsException{}//子类；
    public void show04() throws Exception {} //父类
}
class Zi extends Hello{
    //1子类重写父类方法时,抛出和父类相同的异常
    public void show01() throws NullPointerException,ClassCastException{}
    //2子类重写父类方法时,抛出父类异常的子类
    //ArrayIndexOutOfBoundsException是IndexOutOfBoundsException的子类
    public void show02() throws ArrayIndexOutOfBoundsException{}
    //3子类重写父类方法时,不抛出异常
    public void show03() {}
/*
        父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。
     */
    //public void show04() throws Exception{} 
    //此时子类产生该异常，只能捕获处理try-catch，不能声明抛出
    public void show04()  {
        try {
            throw  new Exception("编译期异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1_7_1_13_自定义异常类-注册异常的类

E:\0-2019黑马\1.Java基础笔记\16.【异常、线程】-笔记\code\05_ExceptionAndThread\src\com\itheima\demo04\MyException

 自定义异常类：java提供的异常类,不够我们使用,需要自己定义一些异常类

    格式:

        public class XXXExcepiton extends Exception | RuntimeException{//   这里的 | 是或者的意思

            添加一个空参数的构造方法

            添加一个带异常信息的构造方法

        }

     注意:

        1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类

        2.自定义异常类,必须的继承Exception或者RuntimeException

            继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常 

            要么throws,要么try...catch

            继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)

public class Hello extends /*Exception*/ RuntimeException{
    //添加一个空参数的构造方法
    public Hello(){
        super();
    }
//  添加一个带异常信息的构造方法
//  查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息
    public Hello(String message){
        super(message);
    }
}

1_7_1_14_自定义异常类的练习

E:\0-2019黑马\1.Java基础笔记\16.【异常、线程】-笔记\code\05_ExceptionAndThread\src\com\itheima\demo04\MyException  的文件：Demo02RegisterException.java

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

 分析:

        1.使用数组保存已经注册过的用户名(数据库)

        2.使用Scanner获取用户输入的注册的用户名(前端,页面)

        3.定义一个方法,对用户输入的中注册的用户名进行判断

            遍历存储已经注册过用户名的数组,获取每一个用户名

            使用获取到的用户名和用户输入的用户名比较

                true:

                    用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";

                    //RegisterException异常是自定义异常

                false:

                    继续遍历比较

            如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";

RegisterException.java的代码

public class RegisterException extends Exception{
    //添加一个空参数的构造方法
    public RegisterException(){
        super();
    }

public RegisterException(String message){
        super(message);
    }
}

 Hello.java的程序

import java.util.Scanner;
public class Hello {
    // 1.使用数组保存已经注册过的用户名(数据库)//静态的用户名
    static String[] usernames = {"张三","李四","王五"};
public static void main(String[] args) {
        //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名:");
        String username = sc.next();
        checkUsername(username);
}
//3.定义一个方法,对用户输入的中注册的用户名进行判断
    public static void checkUsername(String username)  {
        //遍历存储已经注册过用户名的数组,获取每一个用户名
        for (String name : usernames) {//usernames是一个数组
            //使用获取到的用户名和用户输入的用户名比较
            if(name.equals(username)){
                //true:用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";           
            		try {
						throw new RegisterException("亲，该用户名已经被注册");
					} catch (RegisterException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}//抛出运行期异常,无需处理,交给JVM处理,中断处理
              return;//用来结束的代码
            }
        }
//如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
        System.out.println("恭喜您,注册成功!");
    }
}

runtime运行期异常语句public class RegisterException extends RuntimeException  就是将registerException中的Exception改为了RuntimeException ，可以不用try-catch语句

Exception改为了RuntimeException 

public class RegisterException extends RuntimeException{
    //添加一个空参数的构造方法
    public RegisterException(){
        super();
    }
public RegisterException(String message){
        super(message);
    }
}

import java.util.Scanner;
public class Hello {
    // 1.使用数组保存已经注册过的用户名(数据库)//静态的用户名
    static String[] usernames = {"张三","李四","王五"};
public static void main(String[] args) {
        //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名:");
        String username = sc.next();
        checkUsername(username);
}
//3.定义一个方法,对用户输入的中注册的用户名进行判断
    public static void checkUsername(String username)  {
        //遍历存储已经注册过用户名的数组,获取每一个用户名
        for (String name : usernames) {
            //使用获取到的用户名和用户输入的用户名比较
            if(name.equals(username)){
                //true:用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
            	throw new RegisterException("亲，该用户名已经被注册"); 
            	//这里用运行期异常，应该是直接结束了，不用return;
            }
        }
//如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
        System.out.println("恭喜您,注册成功!");
    }
}

 

 

 

 

 

 

 

 

 

 

 

自渡2021
关注
专栏目录
第1章 线程管理-C++11/14/17/20
Venus_majian
11-24 977
C++线程库还是很强大的，非常有用。
有序单链表的合并 {啊啊啊啊~~数据结构第一次ac出的题目，幸福得沙雕} 虽然程序不可避免的复杂
qq_45774885的博客
02-29 400
【问题描述】 两个非降序链表的并集，例如将链表1->2->3 和 2->3->5 并为 1->2->3->5，只能输出结果，不能修改两个链表的数据。 【输入形式】 第一行首先是数据的个数，然后是第一个链表的各结点值，以空格分隔。 第二行首先也是数据的个数，然后是第二个链表的各结点值，以空格分隔。 【输出形式】 合并好的链表，以非降序排列，值与值之间以空格分...
合并链表 【微软面试100题 第四十二题】
tractor_man的专栏
11-06 489
题目要求： 　　两个非降序链表的并集，1->2->3和2->3->5合并为1->2->3->5. 　　另外只能输出结果，不能修改两个链表的数据。 题目分析： 　　1.不能修改原链表数据：即，输出1->2->3->5后，原来的两个链表还是1->2->3和2->3->5。因此输出的这些结点都需要重新申请空间存放，不能使用原来的结点。 　　2.去掉相同值的结点。即，如果he
数据结构学习记录1-链表
xxy41092的博客
07-10 335
//单链表：每个节点储存数据和指针指向下一个节点 #include&lt;cstdio&gt;#include&lt;cstdlib&gt;#include&lt;cstring&gt;using namespace std;struct list{ int data; struct list *next;}*head,*t;int w;//使用结构体储存链表的每一个结点void createli...
Leetcode015--合并两个有序链表
蜕变的快乐
11-30 667
将两个有序的单链表进行合并的操作
两个非降序链表的并集
nciaebupt
06-26 5778
/* copyright@nciaebupt 转载请注明出处 题目：两个非降序链表的并集，1->2->3 和 2->3->5 并为 1->2->3->5 另外只能输出结果，不能修改两个链表的数据。 */ #include #include struct List{ int value; List * next; }; List * createList(int * arr, i
[Visual[1].C#_2010从入门到精通]中文版(1-29章)(附代码)
09-11
10. **多线程编程**：了解如何在C#中实现并发和异步操作，以充分利用多核处理器的优势。 11. **文件与I/O操作**：学习读写文件、目录管理和资源处理等操作，以便程序能够与本地文件系统交互。 12. **网络编程**：...
Java电子教案(PPT)-第1章-Java简介(ppt文档).ppt
最新发布
11-13
Java电子教案的第一章主要介绍了Java语言的基本...对于后续的Java编程、面向对象设计、异常处理、IO流、多线程、网络编程等内容，都需要牢固掌握本章的知识作为支撑。因此，读者务必重视并投入足够的时间去理解和实践。
第一行代码Java源代码第1章课程代码Java简介共1
10-31
【标题】"第一行代码Java源代码第1章课程代码Java简介共1" 指的是一个关于Java编程语言入门的教程，源自郭霖的畅销书《第一行代码——Java》的第一章。这个标题暗示了内容可能涵盖了Java编程的基础概念，可能是为了...
第六章 ReentrantLock源码解析2--释放锁unlock()1
08-04
ReentrantLock源码解析之释放锁unlock() ReentrantLock是一个可重入锁，它提供了一个unlock()方法来释放锁。...ReentrantLock的unlock()方法提供了一个安全的释放锁机制，确保了多线程环境下的线程安全性。
21. 合并两个有序链表
西北交际花的博客
12-08 147
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1-&gt;2-&gt;4, 1-&gt;3-&gt;4 输出：1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4 解题思路： 先挨个比较两个链表的首元素，取其中的较小值接入链表，将该较小值所在链表指向该较小值的下一个值，以此类推直到两个链表中的每一条完全接入新链表，再把另一条链...
合并链表（C语言实现）
weixin_56273009的博客
04-06 4991
【问题描述】 两个非降序链表的并集，例如将链表1->2->3 和 2->3->5 并为 1->2->3->5，只能输出结果，不能修改两个链表的数据。 【输入形式】 第一行为第一个链表的各结点值，以空格分隔。 第二行为第二个链表的各结点值，以空格分隔。 【输出形式】 合并好的链表，以非降序排列，值与值之间以空格分隔。 【样例输入】 4 7 10 34 1 4 6 29 34 34 52 【样例输出】 1 4 6 7 10 29 34 52 【评...
【100题】第四十一题 非降序链表的并集
小田的专栏
08-19 2993
一，题目       两个非降序链表的并集，1->2->3 和 2->3->5 并为 1->2->3->5。另外只能输出结果，不能修改两个链表的数据。 二，递归解法   #include using namespace std; struct Node { int data; Node * next; }; Node *
写正确函数需要注意的地方：两个非降序链表的并集，1>2>3和2>3>5合并为1>2>3>5。
chjjunking的专栏
09-10 4509
int OutCombine(Node* p1, Node* p2) { while(p1!=NULL && p2!=NULL) { if(p1->value>p2->value) { coutvalue<<" "; p2=p2->pNext; } else if(p1->valuevalue) { coutvalue<<" "; p1=p1->pN
两个链表的合并
m0_38040146的博客
09-18 308
题目要求： 注意题目中的一句话，要求我们使用原来序列中的结点！那么我们就不能使用新的内存单元，来单独存储合并后的链表。 【如果申请新内存，pta会报段错误】 使用原来的结点：优点，节省内存；缺点，破坏了原来的链表，不能原样输出原链表## 使用新内存单元：优点，保存原链表状态；缺点，浪费内存## 使用原来结点的代码： List Merge(List L1, List L2) { ...
微软等面试100题系列 - 41
leochou_xm的专栏
04-12 321
41.请修改append函数，利用这个函数实现： 两个非降序链表的并集，1->2->3 和 2->3->5 并为 1->2->3->5 另外只能输出结果，不能修改两个链表的数据。   此题，合并链表，要求将俩个非有序排列的链表，有顺序的合并。 package com.algorithm.interview; public class LinkMerge {
双向链表简单的存储与排序
weixin_43913556的博客
03-18 1349
【问题描述】输入n个整数，创建一个双向循环链表进行存储。这些整数从第二个开始，递增有序（设a2<a3<…<an） (ai为第i个整数)。试编写程序，创建双向循环链表，依次将输入的整数存储在该链表的各节点中。然后，将第一个结点删除并插入链表中的适当位置，使整个链表递增有序。 【输入形式】先输入整数的个数，再输入整数列。 【输出形式】以整数递增的顺序，依次输出双向循环链表各个节点存储...
数据结构之双向循环链表的操作C的实现
weixin_43700556的博客
03-18 3103
关于双向循环链表操作的一道题 【问题描述】输入n个整数，创建一个双向循环链表进行存储。这些整数从第二个开始，递增有序（设a2<a3<…<an） (ai为第i个整数)。试编写程序，创建双向循环链表，依次将输入的整数存储在该链表的各节点中。然后，将第一个结点删除并插入链表中的适当位置，使整个链表递增有序。 【输入形式】先输入整数的个数，再输入整数列。 【输出形式】以整数递增的顺序，依...
链表合并
weixin_43913556的博客
03-13 1114
【问题描述】 两个非降序链表的并集，例如将链表1-&gt;2-&gt;3 和 2-&gt;3-&gt;5 并为 1-&gt;2-&gt;3-&gt;5，只能输出结果，不能修改两个链表的数据。 【输入形式】 第一行首先是数据的个数，然后是第一个链表的各结点值，以空格分隔。 第二行首先也是数据的个数，然后是第二个链表的各结点值，以空格分隔。 【输出形式】 合并好的链表，以非降序排列，值与值之间以空格分...
Java 7 OCP认证深度指南：1Z0-804/805考试详解与实战
2. **类设计**：第3章和第4章深入探讨Java类设计原则，包括高级类设计技巧，这对于理解面向对象编程至关重要。 3. **泛型和集合**：第6章讲解了Java中的泛型和集合框架，帮助考生掌握数据结构和算法在实际项目中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值