java 基础点滴(一）

最新推荐文章于 2020-12-22 22:22:00 发布
原创 最新推荐文章于 2020-12-22 22:22:00 发布 · 141 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #XML

本文介绍使用JDOM库进行XML文件的读写、增删改查操作，并提供了一个将不连续数字按连续段分组的示例程序。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. --jdom 读取XML数据


package test.xy.jdom;

import org.jdom.*;
import org.jdom.input.*;
import org.jdom.output.*;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.List;
public class MyJDom {
    public static void main(String[] args) throws Exception{
        SAXBuilder sb=new SAXBuilder();//建立构造器
        Document doc=sb.build(new FileInputStream("src/xml/test.xml"));//读入指定文件
        Element root=doc.getRootElement();//获得根节点
        List list=root.getChildren();//将根节点下的所有子节点放入List中
        for(int i=0;i<list.size();i++) {
            System.out.println("---------------------------");
            Element item=(Element)list.get(i);//取得节点实例
            String id=item.getAttribute("id").getValue();//取得属性值
            System.out.println("id-->"+id);

            Element sub=item.getChild("title");//取得当前节点的字节点
            String text=sub.getText();//取得当前节点的值
             System.out.println("Title-->"+text);
            if(item.getChild("content").getChildren().size()>0){
            Element sub2=item.getChild("content").getChild("name");
            Element age=item.getChild("content").getChild("age");
                String text2=sub2.getText();
                String ageText=age.getText();
                System.out.println("the age is:"+ageText);
                System.out.println("name-->"+text2);
            }


            Element sub3=item.getChild("email");
            String text3=sub3.getText();
            System.out.println("Email-->"+text3);
        }
      }
}

<?xml version="1.0" encoding="UTF-8"?>
<messages>
<message id="1">
   <title>biaoti_1</title>
   <content>
    <name>zhanghua</name>
    <age>30</age>
   </content>
   <email>zhanghua123@126.com</email>
</message>
<message id="2">
   <title>biaoti_2</title>
   <content>
    <name>lining</name>
    <age>28</age>
   </content>
   <email>lining123@126.com</email>
</message>
</messages>

------------------------------- 1 结束----------------------

2. -- jdom对XML(增，删，改，查）


  import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.List;

	import org.jdom.Document;
	import org.jdom.Element;
	import org.jdom.JDOMException;
	import org.jdom.input.SAXBuilder;
	import org.jdom.output.XMLOutputter;

	/**
	 * 
	 */
	public class JavaXML {


	 //解析xml文件

	 public static void XmlParse() throws JDOMException, IOException {
	  SAXBuilder builder = new SAXBuilder();
	  InputStream file = new FileInputStream("src/xml/po.xml");
	  Document document = builder.build(file);//获得文档对象
	  Element root = document.getRootElement();//获得根节点
	  List<Element> list = root.getChildren();
	  for(Element e:list) {
	   System.out.println("ID="+e.getAttributeValue("id"));
	   System.out.println("username="+e.getChildText("username"));
	   System.out.println("password="+e.getChildText("password"));
	  }
	 }

	 //增
	 public static void addXml() throws JDOMException, FileNotFoundException, IOException {
	  SAXBuilder builder = new SAXBuilder();
	  Document doc = builder.build("src/xml/po.xml");//获得文档对象
	  Element root = doc.getRootElement();//获得根节点

	  //添加新元素
	  Element element = new Element("person");
	  element.setAttribute("id", "3");
	  Element element1 = new Element("username");
	  element1.setText("HONGWEI");
	  Element element2 = new Element("password");
	  element2.setText("mima");
	  element.addContent(element1);
	  element.addContent(element2);
	  root.addContent(element);
	  doc.setRootElement(root);

	  //文件处理
	  XMLOutputter out = new XMLOutputter();
	  out.output(doc, new FileOutputStream("src/xml/po.xml"));
	 }

	 //根据ID值删除一个节点 
	 public static void deletePerson(int id) throws JDOMException, IOException {
	  SAXBuilder builder = new SAXBuilder();
	  InputStream file = new FileInputStream("src/xml/po.xml");
	  Document doc = builder.build(file);//获得文档对象
	  Element root = doc.getRootElement();//获得根节点
	  List<Element> list = root.getChildren();
	  for(Element e:list) {
	   //获取ID值
	   if(Integer.parseInt(e.getAttributeValue("id"))==id) {
	    root.removeContent(e);
	    break;//??
	   }
	  }

	  //文件处理
	  XMLOutputter out = new XMLOutputter();
	  out.output(doc, new FileOutputStream("src/xml/po.xml"));
	 }

	 //根据ID值修改一个节点 
	 public static void updatePerson(int id) throws JDOMException, IOException {
	  SAXBuilder builder = new SAXBuilder();
	  InputStream file = new FileInputStream("src/xml/po.xml");
	  Document doc = builder.build(file);//获得文档对象
	  Element root = doc.getRootElement();//获得根节点
	  List<Element> list = root.getChildren();
	  for(Element e:list) {
	   //获取ID值
	   if(Integer.parseInt(e.getAttributeValue("id"))==id) {
	    System.out.println("--------------------");
	    e.getChild("username").setText("111111111");
	    e.getChild("password").setText("password");

	   }
	  }

	  //文件处理
	  XMLOutputter out = new XMLOutputter();
	  out.output(doc, new FileOutputStream("src/xml/po.xml"));
	 }

	 static public void main(String ars[]) throws JDOMException, IOException {

	  //addXml();//增加XML
	 // deletePerson(3);//删除XML
	 // updatePerson(2);//修改XML
	  //XmlParse();//解析XML
	 }
	}

<?xml version="1.0" encoding="UTF-8"?>
<root>
 <person id="1">
  <username>张三</username>
  <password>123123</password>
 </person>
 <person id="2">
  <username>1111111112</username>
  <password>password2</password>
 </person>

<person id="3">
<username>liming</username>
<password>mima</password></person>

<person id="3">
<username>liushan</username>
<password>mima</password></person>
</root>




----------------------- 2 结束 -------------------------------

3. -- java split 与tokenizer的区别
String sample1="ben ben" ; //其中连个ben之间间隔8个空格

String[] split1 = sample1.split(" "); //通过一个空格隔离

StringTokenizer tokens = new StringTokenizer(sample1, " ");
List ls = new ArrayList();
while(tokens.hasMoreTokens()){
String str = (String)tokens.nextElement();
ls.add(str);
}

结果：split1.length 为 9 ls.size 为 2
解释：如果用split进行分离的话，他会将空格也作为一个字符串存入数组， 而tokenizer不会

--------------------------- 3 结束-------------------------------------

4. 把不连续的数字按部分连续的段分组（代码见附件TestGroup.rar）


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;


public class TestGroup {
	public static void main(String args[]){
	int[] systemArray = {10,11,12,13,55,606,56,57,58,59,61,70,79,80,86,87,88,89,600,800};

	TestGroup test = new TestGroup();
	Arrays.sort(systemArray);
	List listGroup = (ArrayList) test.getSystemGroup(systemArray);
	System.out.println(" ------------begin----------");
	for(int i = 0; i < listGroup.size(); i++){

		List pageList = (List)listGroup.get(i); //get page

		System.out.println("current page is:" + i);
		System.out.println("页范围：" + pageList.get(0) + "--" + pageList.get(1));

	}
	System.out.println(" ------------end----------");	
	}
	//systemList 是排序过的不连续的系统号码
	public List<Object> getSystemGroup(int[] systemArray){

		List<Object> groupList = new ArrayList<Object>();//保存每段的pageList
		List<Integer> pageList = new ArrayList<Integer>();

		Integer pageMinNum = 0;//当前连续页系统号最小值
		Integer pageMaxNum = 0;//当前连续页系统号最大值

		//如果是连续的取(systemMin取首个数据)和（systemMax取第二个数据)保存到pageList.add
		//
		int systemArrayLen = systemArray.length;

		//如果当前数据和上一个数据是连续的数据，设置systemMaxNum = 当前数据，继续下一个数据判断，
		//连续的数据从systemMin到systemMin为一页。
		//连续的判断是当前数据+1 是否等于上一个数据。
		for(int i = 0; i < systemArrayLen; i++){		

			if(i == 0){
				pageList = new ArrayList<Integer>();
				pageMinNum = systemArray[i];
				pageMaxNum = systemArray[i];
				pageList = new ArrayList<Integer>();
				pageList.add(pageMinNum);
				pageList.add(pageMaxNum);
				groupList.add(pageList);
				//如果当前数据不是最后一个数据，则下一页的最小值是当前下一个数据（ systemList.get(i+1) ）;
				if((i + 1) < systemArrayLen){
					pageMinNum = systemArray[i+1];
				}


			}else{

				int preSystemNum = 0;
				int currentSystemNum = 0;

				preSystemNum = systemArray[i-1];
				currentSystemNum = systemArray[i];
				//连续的数据，继续判断下一个
				if(currentSystemNum == (preSystemNum + 1)){
					pageMaxNum = currentSystemNum;

					//如果当前是最后一个数据，不再判断
					if(i == (systemArrayLen - 1) ){
						pageList = new ArrayList<Integer>();
						pageList.add(pageMinNum);
						pageList.add(pageMaxNum);
						groupList.add(pageList);
					}

				}
				else{//不连续的数据,只有一个的情况
					pageList = new ArrayList<Integer>();
					pageList.add(pageMinNum);
					pageList.add(pageMaxNum);
					groupList.add(pageList);

					//如果当前数据不是最后一个数据，则下一页的最小值是当前数据（ currentSystemNum）;
					if((i + 1) < systemArrayLen){
						pageMinNum = currentSystemNum;
						pageMaxNum = pageMinNum;//如果是不连续数据，只一页，设置最大值等于最小值。
					}

					//如果当前是最后一个数据，不再判断
					if(i == systemArrayLen - 1){
						pageMinNum = currentSystemNum;
						pageMaxNum = pageMinNum;//如果是不连续数据，只一页，设置最大值等于最小值。
						pageList = new ArrayList<Integer>();
						pageList.add(pageMinNum);
						pageList.add(pageMaxNum);
						groupList.add(pageList);
					}
				}

			}

		}

		return groupList;

	}


}


------------------------------- 4结束----------------------


5同步的例子


public class TestCurrentThread {

	private static int[]arrayb = new int[100];
	private static int countNum; //计数器

	private synchronized int addQueryNeCount(){


		if(countNum <= 2000){
			countNum += 20;
		}

		System.out.println(Thread.currentThread().getName()+" 当前线程查询出 countNum:" + countNum);
		return countNum;

	}

	private synchronized int abstractQueryNeCount(){


		if(countNum >= 0){
			countNum -= 30;
		}

		System.out.println(Thread.currentThread().getName()+" 当前线程查询出 countNum:" + countNum);
		return countNum;

	}

	//同步部件方法导致阻塞
	public  synchronized void printArraya(){

		//查询网元个数，如果网元个数大于60，当前线程阻塞
		int neCount = addQueryNeCount();

		while(neCount > 100){
			System.out.println(Thread.currentThread().getName()+"111111111111111111111111");
			System.out.println(Thread.currentThread().getName()+"：当前部件线程被阻塞--count:"+countNum);
			try {
				wait();
				System.out.println(Thread.currentThread().getName()+"ccccccccccccccccccccccccccc");

			} catch (InterruptedException e) {

				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+"：部件线程同步完成 --count:"+countNum);
	}

	//同步部件方法解除阻塞
	public  synchronized void printArrayb(){

		//查询网元个数，如果网元个数大于60，当前线程阻塞
		int neCount = abstractQueryNeCount();

		if(neCount >100){
			System.out.println(Thread.currentThread().getName()+"：正在解除被阻塞的线程塞--count:"+countNum);

		}else{
			System.out.println(Thread.currentThread().getName()+"：已经解除阻塞--count:"+countNum);
			notifyAll();
		}
	}

    public void test(){
    	System.out.println("当前线程："+ Thread.currentThread().getName());
    	InnerBlockClass innerThread1 = new InnerBlockClass();
    	InnerBlockClass innerThread2 = new InnerBlockClass();
    	InnerBlockClass innerThread3 = new InnerBlockClass();
    	InnerBlockClass innerThread4= new InnerBlockClass();
		InnerBlockClass innerThread5 = new InnerBlockClass();
		InnerBlockClass innerThread6 = new InnerBlockClass();
		InnerBlockClass innerThread7 = new InnerBlockClass();
		InnerBlockClass innerThread8 = new InnerBlockClass();
		InnerBlockClass innerThread9 = new InnerBlockClass();

		innerThread1.start();
		innerThread2.start();
		innerThread3.start();
		innerThread4.start();
		innerThread5.start();
		innerThread6.start();
		innerThread7.start();
		innerThread8.start();
		innerThread9.start();



		InnerUnBlockClass innerOpenThread1 = new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread2 = new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread3 = new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread4= new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread5 = new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread6 = new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread7 = new InnerUnBlockClass();
		InnerUnBlockClass innerOpenThread8 = new InnerUnBlockClass();

		innerOpenThread1.start();
		innerOpenThread2.start();
		innerOpenThread3.start();
		innerOpenThread4.start();
		innerOpenThread5.start();
		innerOpenThread6.start();
		innerOpenThread7.start();
		innerOpenThread8.start();
    }
	public static void main(String args[]){
		TestCurrentThread test = new TestCurrentThread();
		test.test();

	}
	//导致阻塞的线程
	private class InnerBlockClass extends Thread{
		public void run(){
			printArraya();
		}
	}

	//解除阻塞的线程
	private class InnerUnBlockClass extends Thread{
		public void run(){
			printArrayb();
		}
	}
}
阶段一：Java基础入门
weixin_46312449的博客
09-01 224
首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致。目前，Java 由于其优秀的特性以及火爆的生态，岗位需求量大，是后台开发、安卓开发、大数据开发的主流编程语言，因此学习资源也很丰富，值得学习！...
Java 基础
猪猪
02-20 105
java
C++读取简单数据保存在数组中
u010559586的博客
04-24 4009
#include<stdio.h> int main() { FILE *f; int a[2],i; f=fopen(“C:\a.txt”,“r”);//假设文件a.txt第一行是1，第二行是2 if(f==NULL) { printf(“没有该文件”); return; } for(i=0;i<2;++i) fscanf(f,"%d",&a[i]); fclose(f...
Java基础点滴
aihuo4431的博客
03-10 92
1. 关于interface的定义 [修饰符] interface 接口名 [extends 父接口名列表]{ [public] [static] [final] 常量;[public] [abstract] 方法;} 注意，斜体的部分代表是缺省的，默认的，即便声明的时候不写，也会在编译时默认加上。尤其是常量需要注意，继承的子类不能修改接口中声明的常量。另外，修饰...
Java基础-点滴间的积累
〆゛Care的博客
12-22 189
数据类型 基本类型（四类八种） byte char short (-128~127) int float long double boolean 包装类型 Integer a = 1;//使用了自动装箱，调用了Integer.valueOf(1) int b = a;//使用了自动拆箱，调用了 a.intValue() 缓存池 Integer a = new Integer(2); //每次都会新建一个对象 Intger b = Integer.valueOf(2); //使用缓存池
Java基础点滴记录
weixin_34396103的博客
09-15 96
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA 基础点滴1
xiang13127的博客
06-18 245
基本类型是传值的；引用类型是传引用的 1.字符串内容的对比  equals（）：检查组成字符串内容的字符是否完全一致。  ==：判断两个字符串在内存中的首地址既判断是否是同一个字符串对象。 字符串String的常用操作： 输出结果： StringBuffer的使用： StringBuffer和String属于不同的类型，也不能直接进行强制类型转换，下面的代码都是错误的
java基础知识点滴整理（一）
zixiao_YING的专栏
06-02 474
1.八种基本类型：boolean，byte，char，short，int，float，long，double（其中boolean占1bit，1/8字节；byte占1字节；short和char占2字节；int和float占4字节；long和double占8个字节） 2.补码的计算规则：正数的补码和原码相同；负数的补码是其反码+1；反码是对原码按位取反，只是最高位（符号位）保持不变 3.i++底层
Java基础知识(一)——基本概念篇
复制乔布斯
10-07 3758
目录 1、Java语言有哪些优点 1）Java为纯面向对象的语言。 2）平台无关性。 3）Java提供了很多内置的类库 4）提供了对Web应用开发的支持， 5）具有较好的安全性和健壮性。 6）去除了C++语言中难以理解、容易混淆的特性， 2、Java与C/C++有什么异同 1）Java为解释性语言，其运行过程为： 2）Java为纯面向对象语言 3）Java语言中没有指针的概念...
我的学习笔记，记录从零学习java的点滴
01-28
Java 虚拟机是 Java 应用程序运行的基础环境。它是一种抽象的计算机，具备自己的寄存器、堆栈和垃圾回收机制等。JVM 可以执行由 Java 编译器生成的字节码 (Bytecode)，这是一种中间语言，而不是直接的机器指令。不同...
点滴积累筑基石：Java、算法、数据库等知识总结与分享
07-31
文档中关于Java基础的总结，涵盖了Java语言的基本概念、语法结构、面向对象的特性、异常处理等核心知识点，这些都是任何一个Java开发者必须熟练掌握的基础。 紧接着，数据结构与算法是衡量程序员逻辑思维和解决问题...
算法_Leetcode_Java刷题_记录点滴_1741872564.zip
03-15
通过对《算法_Leetcode_Java刷题_记录点滴》的学习，读者不仅可以提升编程能力，还能够在此过程中学会如何将理论知识运用到实际问题的解决中，为日后的技术发展打下坚实的基础。 简介.txt 文件可能包含整个文档的...
Python实现简单的HTTP服务器.doc
08-14
Python实现简单的HTTP服务器.doc
北京理工大学2021小学期计算机组成原理课程设计项目-基于硬件描述语言实现的精简计算机系统-包含单周期CPU和流水线CPU两种架构-支持斐波那契数列计算与显示功能-采用高度模块化设.zip
08-14
python北京理工大学2021小学期计算机组成原理课程设计项目_基于硬件描述语言实现的精简计算机系统_包含单周期CPU和流水线CPU两种架构_支持斐波那契数列计算与显示功能_采用高度模块化设.zip
2025年爱眼护眼知识竞赛题库与答案.docx
08-14
2025年爱眼护眼知识竞赛题库与答案.docx
基于MPC最优控制的车辆自适应巡航系统(Cars im & Mat lab)实现速度与间距智能调控
最新发布
08-14
内容概要：本文介绍了基于模型预测控制(MPC)的车辆自适应巡航控制系统(ACC)，重点探讨了如何利用Cars im与Mat lab联合仿真实现速度与间距的智能调控。首先解释了MPC作为一种优化方法，在控制系统设计中的关键作用，特别是在预测系统未来行为方面的能力。接着详细描述了ACC的工作原理，即通过传感器获取车辆运动状态和道路环境信息，再由控制器使用MPC算法计算最优控制策略，最终由执行器完成具体的油门、刹车和转向操作。文中还提到，通过Cars im模拟不同的道路环境和交通场景，并将其输入到Mat lab中设计的MPC控制器中进行处理，实现了对车辆速度和间距的精准控制。 适合人群：从事智能驾驶技术研发的专业人士，尤其是对车辆自适应巡航控制系统感兴趣的工程师和技术研究人员。 使用场景及目标：适用于希望深入了解MPC在智能驾驶领域的应用，特别是想掌握如何用Cars im和Mat lab进行联合仿真的技术人员。目标是提升车辆行驶的安全性和舒适度，同时探索更多智能驾驶的可能性。 其他说明：文章不仅阐述了理论概念，还提供了实际的操作步骤，有助于读者更好地理解和应用相关技术。此外，强调了智能驾驶技术在未来汽车工业发展中的重要地位。
React中实现表格数据分页与排序功能.doc
08-14
React中实现表格数据分页与排序功能.doc
C# WinForms仓库温控管理系统的自定义控件与实时数据处理
08-14
作者在开发C#仓库温控管理系统时遇到的技术难题及其解决方案。系统基于WinForms框架构建，重点在于自定义控件的应用，如圆角面板控件、温度仪表盘控件以及实时数据刷新机制。文中不仅展示了具体的代码实现细节，还分享了许多实用的经验技巧，如利用GraphicsPath创建圆角面板、通过数学公式绘制带有物理惯性的温度指针、采用ConcurrentQueue和定时器解决实时数据刷新导致的UI卡顿问题等。 适合人群：对C#编程有一定基础，尤其是熟悉WinForms框架的开发者。 使用场景及目标：适用于希望深入了解WinForms自定义控件开发、掌握高效的数据处理方法以及提升用户体验的设计人员。通过学习本文，读者可以更好地理解和应用WinForms框架进行复杂项目的开发。 阅读建议：本文提供了丰富的实战经验和具体代码示例，建议读者结合自己的项目需求逐步尝试文中提到的各种技术和方法，在实践中加深理解。同时，对于一些较为复杂的概念和技术点，可以通过查阅相关资料进一步巩固知识。
揭秘JAVA程序员日常工作点滴
知识点1：Java基础 Java程序员首先需要掌握Java语言的基础知识，包括Java语法、数据类型、控制结构、数组、字符串处理等。此外，对象导向的编程概念如类与对象、继承、封装、多态也是必备的。掌握集合框架、异常处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值