Android学习-JAVA基础 (三)，2024年最新京东最新java面试真题解析及答案

最新推荐文章于 2024-07-16 15:26:55 发布

2401_84434301

最新推荐文章于 2024-07-16 15:26:55 发布

阅读量1k

点赞数 9

分类专栏： 2024年程序员学习文章标签： android 学习 java

本文链接：https://blog.csdn.net/2401_84434301/article/details/137897970

版权

2024年程序员学习专栏收录该内容

29 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

public static void main(String[] args) {

    ExecutorService es = Executors.newCachedThreadPool();



    //端口号从1024~65535

    try {

        ServerSocket ss = new ServerSocket(8001);

        System.out.println("服务器已启动，正在等待连接...");

        while(true){

            Socket socket = ss.accept();//等待客户端连接，该方法会阻塞(客户端执行了它才会执行)

            //每一次过来都传到线程中去，然后继续等待

            es.execute(new ClientThread(socket));

        }



    } catch (IOException e) {

        e.printStackTrace();

    }

}

//处理客户端请求的线程

static class ClientThread implements Runnable{



    private Socket socket;

    public ClientThread(Socket socket){

        this.socket =socket;

    }

    public void run() {

        try {

            System.out.println("客户端的ip为："+socket.getInetAddress().getHostName());

            InputStream in = socket.getInputStream();

            BufferedReader br = new BufferedReader(new InputStreamReader(in));

            //返回响应

            OutputStream out = socket.getOutputStream();

            PrintStream ps = new PrintStream(out);



            while(true) {

                String data = br.readLine();

                if(data == null ||  data.equals("bye")){

                    break;

                }

                System.out.println("data"+data);

                ps.println("data=="+data);

            }

            in.close();

            out.close();



        } catch (IOException e) {

            e.printStackTrace();

        }

    }



}

}

package com.test.testjva.serverAndClient.muit;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintStream;

import java.net.Socket;

import java.util.Scanner;

public class MuitClient {

//传输过程：

//1.客户端通过输出流把数据发送到服务器（客户端可以先写一个输入流等待着）

//2.服务器通过输入流得到数据后再通过输出流返回到客户端

//3.客户端用刚刚写好的输入流得到服务器传来的数据，然后读出来

//连接服务器

public static void main(String[] args) {

    try {

        Socket socket = new Socket("localhost",8001);

        System.out.println("连接成功！");

        boolean flag = true;

        OutputStream out = socket.getOutputStream();

        InputStream in = socket.getInputStream();

        PrintStream ps = new PrintStream(out);

        BufferedReader br = new BufferedReader(new InputStreamReader(in));

        Scanner input = new Scanner(System.in);

        while(flag){

            System.out.println("请输入：");

        String info =    input.next();

        if("bye".equals(info)){

            flag = false;

        }

        ps.println(info);

        info = br.readLine();

        System.out.println("dataclient="+info);

        }

        out.close();

        in.close();



    } catch (IOException e) {

        e.printStackTrace();

    }





}

}




11.客户端与客户端通信

package com.test.testjva.serverAndClient;

public class Info {

private String to;

private String from;

private String info;

private int type;//0表示登录，1表示发送消息

public String getTo() {

    return to;

}

public void setTo(String to) {

    this.to = to;

}

public String getFrom() {

    return from;

}

public void setFrom(String from) {

    this.from = from;

}

public String getInfo() {

    return info;

}

public void setInfo(String info) {

    this.info = info;

}

@Override

public String toString() {

    return "Info [to=" + to + ", from=" + from + ", info=" + info + "]";

}

public Info(String to, String from, String info) {

    super();

    this.to = to;

    this.from = from;

    this.info = info;

}

public Info() {

    super();

    // TODO Auto-generated constructor stub

}

public int getType() {

    return type;

}

public void setType(int type) {

    this.type = type;

}

}

package com.test.testjva.serverAndClient.client;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.Socket;

import java.util.Scanner;

import com.test.testjva.serverAndClient.Info;

public class Client {

public static void main(String[] args) {

    getClient();

}

private static void getClient() {

    try {

        Socket socket = new Socket("localhost",8001);

        System.out.println("连接成功！");

        boolean flag = true;

        ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());

        ObjectInputStream in = new ObjectInputStream(socket.getInputStream());

        Scanner input = new Scanner(System.in);

        System.out.println("请输入姓名：");

        String name = input.nextLine();

        Info info = new Info();

        info.setFrom(name);

        info.setType(0);

        out.writeObject(info);

        try {

            info = (Info) in.readObject();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }//系统返回的信息

        System.out.println(info.getInfo());

        new Thread(new ReadInfoThread(in)).start();

        while(flag){

            info = new Info();

            System.out.println("to：");

            info.setTo(input.nextLine());

            System.out.println("info:");

            info.setInfo(input.nextLine());

            info.setFrom(name);

            info.setType(1);



            out.writeObject(info);



        }

        out.close();

        out.close();



    } catch (IOException e) {

        e.printStackTrace();

    }



}

//接收消息的线程

static class ReadInfoThread implements Runnable{

    private ObjectInputStream in;

    public boolean flag = true;

    public ReadInfoThread(ObjectInputStream in){

        this.in = in;

        flag = true;

    }

    public void run() {

        while(flag) {

            try {

                Info info = (Info) in.readObject();

                System.out.println("收到的消息；"+info.getInfo());

            } catch (ClassNotFoundException e) {

                e.printStackTrace();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }



}

}

package com.test.testjva.serverAndClient.client;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Vector;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import com.test.testjva.serverAndClient.Info;

public class Server {

public static void main(String[] args) {

    ExecutorService es = Executors.newCachedThreadPool();

    //用于存储客户端的服务线程

    Vector<ClientThread> list = new Vector<ClientThread>();

    //端口号从1024~65535

    try {

        ServerSocket ss = new ServerSocket(8001);

        System.out.println("服务器已启动，正在等待连接...");

        while(true){

            Socket socket = ss.accept();//等待客户端连接，该方法会阻塞(客户端执行了它才会执行)

            //每一次过来都传到线程中去，然后继续等待

            ClientThread c = new ClientThread(socket,list);

            es.execute(c);

        }



    } catch (IOException e) {

        e.printStackTrace();

    }

}

//处理客户端请求的线程

static class ClientThread implements Runnable{

    private Socket socket;

    private String name;

    private Vector<ClientThread> list;

    private ObjectOutputStream out;

    private ObjectInputStream in;

    public ClientThread(Socket socket, Vector<ClientThread> list){

        list.add(this);

        this.socket =socket;

        this.list = list;

    }

    public void run() {

        try {

            System.out.println("客户端的ip为："+socket.getInetAddress().getHostName());

            out = new ObjectOutputStream(socket.getOutputStream());

            in = new ObjectInputStream(socket.getInputStream());



            while(true) {

                Info info = null;

                try {

                    info = (Info) in.readObject();

                } catch (ClassNotFoundException e) {

                    e.printStackTrace();

                }

                if(info.getType() == 0) {

                    name = info.getFrom();

                    Info welcome = new Info();

                    welcome.setInfo("welcome"+name);

                } else if(info.getType() == 1) {



                    for (int i = 0; i < list.size(); i++) {

                        ClientThread ct = list.get(i);

                        if(ct.name.equals(info.getTo())) {

                            ct.out.writeObject(info);

                            break;

                        }

                    }

                }

            }



        } catch (IOException e) {

            e.printStackTrace();

        }

    }



}

}




12.反射-Class

package com.test.testjva.reflection;

public class Cat{

//public int count;

private String name;

private int age;

public Cat(String name, int age) {

    super();

    this.name = name;

    this.age = age;

}

public Cat() {

    super();

    // TODO Auto-generated constructor stub

}

public String getName() {

    return name;

}

public void setName(String name) {

    this.name = name;

}

public int getAge() {

    return age;

}

public void setAge(int age) {

    this.age = age;

}

@Override

public String toString() {

    return "Cat [name=" + name + ", age=" + age + "]";

}

private String privateTest(){

return "222";

}

package com.test.testjva.reflection;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

public class Reflection1 {

public static void main(String[] args) {

    getClassObj();



}

//获取一个class类对象

private static void getClassObj() {

    Cat cat= new Cat("jack", 4);

    //3中方式获得类信息

    Class cls = cat.getClass();

    Class cls2 = Cat.class;

    try {

        Class cls3 = Class.forName("com.test.testjva.reflection.Cat");

    } catch (ClassNotFoundException e) {

        e.printStackTrace();

    }



    //通过类信息创建该对象，Cat的无参构造方法必须存在

    try {

        Cat catc = (Cat) cls2.newInstance();

    } catch (InstantiationException e) {

        e.printStackTrace();

    } catch (IllegalAccessException e) {

        e.printStackTrace();

    }



    //获取构造方法

    Constructor[]  cons = cls2.getConstructors();

    for (int i = 0; i < cons.length; i++) {

        System.out.println(cons[i].getName());

    }

    try {

        Constructor constss = cls2.getConstructor(String.class,int.class);

        try {

            Cat c = (Cat) constss.newInstance("jjjj",5);

            System.out.println(c.getName());

        } catch (Exception e) {

            e.printStackTrace();

        }



    } catch (NoSuchMethodException | SecurityException e) {

        e.printStackTrace();

    }

    //得到类信息

    String name = cls2.getPackage().getName();

    //获取所以可用(公共的public)方法

    Method[] medhods = cls2.getMethods();

    for (Method method : medhods) {

        System.out.println(method.getName()+"\\");

    }

    //获取所以可用(公共的)属性

    Field[] f= cls2.getFields();

    for (Field field : f) {

        System.out.println("--"+field.getName());

    }



    //获取本类中定义的所有方法包含private，不包含父类方法

    Method[] mes = cls2.getDeclaredMethods();

    for (Method method : mes) {

        System.out.println(method.getName());

    }



    Field[] fd = cls2.getDeclaredFields();

    for (Field field : fd) {

        System.out.println("==="+field.getName());

        System.out.println(Modifier.toString(field.getModifiers()));

        System.out.println(field.getType().getName());

    }



    //通过反射可以调用类里面private的方法和属性

    try {

        Method md = cls2.getDeclaredMethod("privateTest");

        md.setAccessible(true);

        try {

        String test =   (String) md.invoke(cat);

        System.out.println("test==="+test);

        } catch (Exception e) {

            e.printStackTrace();

        }

    } catch (NoSuchMethodException | SecurityException e1) {

        e1.printStackTrace();

    }



    //在cat对象上获取属性值

    try {

        //运行时忽略访问修饰符的限制

        fd[0].setAccessible(true);

        String nameS = (String) fd[0].get(cat);

        System.out.println(nameS);

    } catch (IllegalArgumentException e) {

        e.printStackTrace();

    } catch (IllegalAccessException e) {

        e.printStackTrace();

    }



}

}




13.动态代理

package com.test.testjva.reflectiondaili;

public interface SubJect {

void shopping();

}

package com.test.testjva.reflectiondaili;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

//必须要做又不是核心业务的代码放在代理中去做

//自己写代理的情况比较少，写这个的目的是因为android里面有很多代理，便于理解别人的代码

//代理要做的事情

public class Proxy implements InvocationHandler{

private SubJect target;



public Proxy(SubJect target) {

    this.target = target;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

        throws Throwable {

    System.out.println("大量评估");



    method.invoke(target, args);



    //代购之后

    System.out.println("满意度调查");



    return null;

}

}

package com.test.testjva.reflectiondaili;

public class SuperMan implements SubJect{

@Override

public void shopping() {

    System.out.println("哥有钱");

}

}

package com.test.testjva.reflectiondaili;

import java.lang.reflect.Proxy;

public class Test {

public static void main(String[] args) {

    SubJect s = new SuperMan();

    com.test.testjva.reflectiondaili.Proxy proxy = new com.test.testjva.reflectiondaili.Proxy(s);

    //动态创建一个代理对象(类加载器，)

    SubJect  obj = (SubJect) Proxy.newProxyInstance(s.getClass().getClassLoader(), s.getClass().getInterfaces(), proxy);

    obj.shopping();

}

}




14.javabean反射和内省

package com.test.testjva.javabean;

public class User {

private String name;

private int num;

public String getName() {

    return name;

}

public void setName(String name) {

    this.name = name;

}

public int getNum() {

    return num;

}

public void setNum(int num) {

    this.num = num;

}

@Override

public String toString() {

    return "User [name=" + name + ", num=" + num + "]";

}

public User(String name, int num) {

    super();

    this.name = name;

    this.num = num;

}

public User() {

    super();

}

}

package com.test.testjva.javabean;

import java.beans.BeanInfo;

import java.beans.IntrospectionException;

import java.beans.Introspector;

import java.beans.PropertyDescriptor;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.Properties;

//（反射和内省）前期用的比较少，写底层框架的时候，用的就比较多了，

//研究框架源代码的时候，就可以看懂了，很多框架源代码都是用反射和内省实现的

public class UserFractory {

private static Properties p = new Properties();

static {

    InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/test/testjva/javabean/user.properties");

    try {

        p.load(in);

    } catch (IOException e) {

        e.printStackTrace();

    }

}

public static User newUser(){

    User u = null;

    try {

        String user = p.getProperty("user");

            Class bClass = Class.forName(user);

            u = (User) bClass.newInstance();

        BeanInfo info = Introspector.getBeanInfo(User.class);

        //获取属性描述器

        PropertyDescriptor[] pds =  info.getPropertyDescriptors();

        for (PropertyDescriptor propertyDescriptor : pds) {

            String name = propertyDescriptor.getName();

            if(name.equals("name")) {

                Method md = propertyDescriptor.getWriteMethod();

                md.invoke(u, p.getProperty("name"));

            }

            else if(name.equals("num")) {

                Method md = propertyDescriptor.getWriteMethod();

                int num = Integer.parseInt(p.getProperty("num"));

                md.invoke(u, num);

            }

        }



    } catch (Exception e) {

        e.printStackTrace();

    }

    return u;

}

}

package com.test.testjva.javabean;

public class UserTest {

public static void main(String[] args) {

    User user = UserFractory.newUser();

    System.out.println("user="+user);

}

}

创建文件：user.properties

user = com.test.testjva.javabean.User

name = my

num = 9




15.泛型

package com.test.testjva.javabean.generic;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.Vector;

public class GenericDemo {

1.通配符

<? extends T> 表示类型的上界，传T的子类 <? super T> 表示类型下界，传T的父类 2.泛型接口 public interface IEat { public void eat(T t); } //你传入的是什么类型，返回的就是什么类型的方法 class IEatImpl implements IEat { @Override public void eat(String t) { System.out.println(t); } } 3.泛型方法 //T[]表示返回值类型，表示泛型化 public static T[] func(T[] array,int i,int t){ T temp = array[i]; array[i] = array[t]; array[t] = array[i]; return array; } 4.嵌套泛型的使用 Map

}

package com.test.testjva.javabean.generic;

//T的上限就代表传入的？（问号）必须是Number的子类（比如Float，Integer），String就不可以；T super Number是相反的，

/*? 通配符类型

<? extends T> 表示类型的上界，传T的子类 <? super T> 表示类型下界，传T的父类 extends 可用于的返回类型限定，不能用于参数类型限定。 super 可用于参数类型限定，不能用于返回类型限定。 >带有super超类型限定的通配符可以向泛型对易用写入，带有extends子类型限定的通配符可以向泛型对象读取。——《Core */ public class Person { private String name; private T age; public String getName() { return name; } public void setName(String name) { this.name = name; } public T getAge() { return age; } public void setAge(T age) { this.age = age; } public Person(String name, T age) { super(); this.name = name; this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } } package com.test.testjva.javabean.generic; public interface IEat { public void eat(T t); } //你传入的是什么类型，返回的就是什么类型的方法 class IEatImpl implements IEat { @Override public void eat(String t) { System.out.println(t); } } ``` 16.正则表达式 > 正则表达式在android中用的比较少，因为正则表达式有一定的效率问题，效率比较低 ``` package com.test.testjva.javabean.Regular; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Regular { //java.util.regex提供正则表达式的支持 //Matcher类,Pattern类 public static void main(String[] args) { String s = "1111"; if(s.matches("\\d+")){ } //参数名是regex的方法都是可以传正则表达式的 //直接使用俩个类的匹配的方式比较少，一般都是用上面的方法 //pattern使用方式 Pattern p = Pattern.compile("aaaa"); Matcher m = p.matcher("aaaa"); boolean b = m.matches(); System.out.println(b); } } ``` 17.DOM解析和SAX解析 ``` package com.test.demo22; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; /* Dom解析的特点：在服务器端开发用的比较多，因为服务器内存大，不在乎 1.整个文档载入内存（占内存），灵活性好，API简单,以树形结构存储 2.SAX(simple API xml),边读边解析，不占用内存,基于事件驱动，不灵活，顺序读取，不能来回跳，速度快（使用与在性能要求较高的设备上使用（比如android））在android中通常就用SAX解析 */ public class DomParse { public static void main(String[] args) { try { List domList = parseXMLByDom(); List saxList = parseXMLBySAX(); for (Person p : saxList) { System.out.println(p); } } catch (Exception e) { e.printStackTrace(); } } private static List parseXMLBySAX() throws Exception { //创建解析工厂 SAXParserFactory factory = SAXParserFactory.newInstance(); //生成解析器 SAXParser sax = factory.newSAXParser(); InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/test/demo22/person.xml"); PersonHandler ph = new PersonHandler(); sax.parse(in, ph); return ph.getPersons(); } private static List parseXMLByDom() throws Exception { // 创建一个文档解析工厂 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); InputStream in = Thread.currentThread().getContextClassLoader() .getResourceAsStream("com/test/demo22/person.xml"); // xml文件的输入流放入解析器中 Document doc = builder.parse(in); Person p = null; List pList = new ArrayList(); NodeList personList = doc.getElementsByTagName("Person"); System.out.println(personList.getLength()); for (int j = 0; j < personList.getLength(); j++) { Node personNode = personList.item(j); String personid = personNode.getAttributes().getNamedItem("personId").getNodeValue(); p = new Person(); p.setPersonId(personid); NodeList personChilds = personNode.getChildNodes(); for (int k = 0; k < personChilds.getLength(); k++) { Node childNode = personChilds.item(k); String name = childNode.getNodeName(); if (name.equals("name")) { p.setName(childNode.getFirstChild().getNodeValue()); } else if (name.equals("age")) { p.setAge(childNode.getFirstChild().getNodeValue()); } else if (name.equals("sex")) { p.setSex(childNode.getFirstChild().getNodeValue()); } } pList.add(p); } return pList; } } package com.test.demo22; public class Person { private String personId; private String name; private String sex; private String age; public String getPersonId() { return personId; } public void setPersonId(String personId) { this.personId = personId; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } @Override public String toString() { return "Person [personId=" + personId + ", name=" + name + ", sex=" + sex + ", age=" + age + "]"; } public Person(String personId, String name, String sex, String age) { super(); this.personId = personId; this.name = name; this.sex = sex; this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } } package com.test.demo22; import java.util.ArrayList; import java.util.List; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; /* 数据处理器 */ public class PersonHandler extends DefaultHandler { private List persons; private Person p; private String tag;// 记录标签名 public List getPersons() { return persons; } // 开始文档解析 @Override public void startDocument() throws SAXException { super.startDocument(); persons = new ArrayList(); System.out.println("开始解析文档"); } @Override public void endDocument() throws SAXException { super.endDocument(); System.out.println("结束解析文档"); } // 开始解析标签<> // 如果标签是的情况的时候，localName只拿person，qName就是拿到（所有标签）a:person @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { super.startElement(uri, localName, qName, attributes); if (qName.equals("Person")) { p = new Person(); String personId = attributes.getValue("personId"); p.setPersonId(personId); } tag = qName; } @Override public void endElement(String uri, String localName, String qName) throws SAXException { super.endElement(uri, localName, qName); if("Person".equals(qName)) { persons.add(p); } tag = null; } // 解析字符 // 处理文本内容（包括空格） @Override public void characters(char[] ch, int start, int length) throws SAXException { super.characters(ch, start, length); String content = new String(ch, start, length); if (tag != null) { if (tag.equals("name")) { p.setName(new String(ch, start, length)); } else if (tag.equals("sex")) { p.setAge(new String(ch, start, length)); } else if (tag.equals("age")) { p.setSex(new String(ch, start, length)); } } } } 创建文件：person.xml <?xml version="1.0" encoding="UTF-8"?>

<Person personId="11">

    <name>张飞</name>

    <sex>男</sex>

    <age>30</age>

</Person>

<Person personId="22">

    <name>关于</name>

    <sex>女</sex>

    <age>22</age>

</Person>




18.Jdom解析和Dom4j解析

package com.test.demo22;

//API简化了，速度比Dom解析快

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.input.SAXBuilder;

public class JDomDemo {

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

大厂面试真题：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
String personId = attributes.getValue(“personId”);

        p.setPersonId(personId);

    }

    tag = qName;



}





@Override

public void endElement(String uri, String localName, String qName)

        throws SAXException {

    super.endElement(uri, localName, qName);

    if("Person".equals(qName)) {

        persons.add(p);

    }

    tag = null;



}



// 解析字符

// 处理文本内容（包括空格）

@Override

public void characters(char[] ch, int start, int length)

        throws SAXException {

    super.characters(ch, start, length);

    String content = new String(ch, start, length);

    if (tag != null) {

        if (tag.equals("name")) {

            p.setName(new String(ch, start, length));

        } else if (tag.equals("sex")) {

            p.setAge(new String(ch, start, length));

        } else if (tag.equals("age")) {

            p.setSex(new String(ch, start, length));

        }

    }

}

}

创建文件：person.xml

<?xml version="1.0" encoding="UTF-8"?>

<Person personId="11">

    <name>张飞</name>

    <sex>男</sex>

    <age>30</age>

</Person>

<Person personId="22">

    <name>关于</name>

    <sex>女</sex>

    <age>22</age>

</Person>




18.Jdom解析和Dom4j解析

package com.test.demo22;

//API简化了，速度比Dom解析快

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.input.SAXBuilder;

public class JDomDemo {

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

[外链图片转存中…(img-XilkZ39B-1713382510935)]

大厂面试真题：

[外链图片转存中…(img-y17iam4i-1713382510936)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-gbk8YhSD-1713382510936)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84434301

关注

9
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
Android学习-JAVA基础 (三)，2024年最新京东最新java面试真题解析及答案

金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
复制链接

扫一扫