Day01

package com.itheima.junitdemo;

public class Demo {
    public static void main(String[] args){
    MyMath math = new MyMath();
    int add = math.add(3, 4);
    System.out.println("result="+add);
    }
}
package com.itheima.junitdemo;
public class MyMath {
    public int add(inti,int j) {
        return i+j;
    }
}

package com.itheima.junitdemo;

import static org.junit.Assert.*;
import org.junit.Test;

public class testMyMath {

    @Test
    public void testAdd() {
        fail("Not yet implemented");
    }
}

package com.itheima.junitdemo;
import static org.junit.Assert.*;
import org.junit.Test;

public class testMyMath {

    @Test
    public void testAdd() {
        MyMath math = new MyMath();
    int result = math.add(2, 3);
//断言拿运行结果和期望结果进行比较如果相同说明测试成功
    assertEquals(5,result);
    }
}

@Deprecated//过时的
    public int add(int i,int j){
        return i+j;
    }

@SuppressWarnings("all")//压制所有警告，
    public static void main(String[] args) {
        MyMath math=new MyMath();
        @SuppressWarnings("deprecation")//压制警告，可以关闭方法或同一行的警告
        int add=math.add(3, 4);
        @SuppressWarnings("unused")//压制警告
        int i=0;
        System.out.println("result="+add);
    }

@Override//复写父类的方法
    public void eat() {
        System.out.println("吃香的");
    }

<?xml version="1.0" encoding="UTF-8"?>
<Person>
 <preson name="liufeng">
  <firstname>feng</firstname>
  <lastname>liu</lastname>
 </preson></Person>

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
  targetNamespace="http://www.itheima.com" 
  elementFormDefault="qualified">
  <xs:element name="书架">
   <xs:complexType>
     <xs:sequence maxOccurs="unbounded">
      <xs:element name="书">
       <xs:complexType>
        <xs:sequence>
          <xs:element name="书名" type="xs:string"/>
          <xs:element name="作者" type="xs:string"/>
          <xs:element name="售价" type="xs:string"/>
        </xs:sequence>
       </xs:complexType>
      </xs:element>
     </xs:sequence>
   </xs:complexType>
  </xs:element>
</xs:schema>

<?xml version="1.0" encoding="UTF-8"?>
<p:书架 xmlns:p="http://www.itheima.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.itheima.com bin/bookSchema.xsd ">
  <p:书>
    <p:书名>p:书名</p:书名>
    <p:作者>p:作者</p:作者>
    <p:售价>p:售价</p:售价>
  </p:书>
</p:书架>

import javax.swing.text.Document;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.NodeList;
public class DomparseTest {
@TEST
public void domParse() throws Exception{
        //获取DocumentBuilderFactory
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//获取DocumentBuilder
DocumentBuilder documentBuilder = builderFactory.newDocumentBuilder();
//通过DocumentBuilder据诶系xml文档获得Docment对象
Document document = documentBuilder.parse("book.xml");
//通过元素的名字可以找到元素的集合
NodeList nodeList = document.getElmentsByTagName("售价");
//nodeList.getLength();
For(int i=0;i<nodeList.getLength();i++){
Node node =nodeList.item(i);
String content = node.getTextContent();
System.out.println(content);
}
//找到第二个元素
Node node = nodeList.item(0);
//读出对应节点的文本内容
String content = node.getTextContent();
System.out.println(content);

@Test
Public void domModifyxml() throws Exception{
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
Documnt document = builder.parse(“book.xml”);
Node node = nodeList.item(i);
//修改节点的内容
Node.setTextContent(“199.00元”);
TranformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFaactory.newTransformer();
//数据源
Source xmlSource = new DomSource(document);
Result outputTarget = new StreamResult(“book.xml”);
Transformer.transform(xmlSourse,outputTarget);
}
}

package com.nbdhyu.temp;

import java.util.logging.Handler;

import javax.sql.rowset.spi.XmlReader;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.junit.Test;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SaxParserTest {
    @Test
    public void saxParse() throws Exception{
        //获取工厂
        SAXParserFactory parserFactory=SAXParserFactory.newInstance();
SAXParser saxParser=parserFactory.newSAXParser();
        //获取xmlRead通过这个reader可以试着contenthandler
        XmlReader xmlReader=saxParser.getXMLReader();
        //给xmlReader设置contenthandler contenthandler是一个接口 里面太多的方法没实现
        //不去直接实现contenthandler 而是继承他默认的实现DefaultHandler
        xmlReader.setContentHandler(new Myhandle());
        //解析xml文档
        xmlReader.parse("book.xml");        
    }
    private class Myhandle extends DefaultHandler{
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            // 文本内容
        String text=new String(ch,start,length);
        System.out.println("文本内容");
        }
         @Override
        public void endDocument() throws SAXException {
            System.out.println("文档结束");                
        }
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            System.out.println("结束标签<"+qName+">");    
        }
         @Override
        public void startDocument() throws SAXException {
            System.out.println("文档开始");        
        }
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes)
                throws SAXException {
            System.out.println("开始标签</"+qName+">");    
        };
    }
}
@Test
    public void saxParserTest2() throws Exception{
        SAXParserFactory parserFactory=SAXParserFactory.newInstance();
        SAXParse parser=parserFactory.newSAXParser();
        XmlReader reader=parser.getXMLReader();
        reader.setContentHandler(new DefaultHandler(){
            boolean isPrice=false;
            int count=0;
            @Override
            public void characters(char[] ch, int start, int length) throws SAXException {
                if (isPrice&&count=2) {
                    System.out.println(new String(ch,start,length));
                    
                }
            }

            @Override
            public void endElement(String uri, String localName, String qName) throws SAXException {
                // TODO Auto-generated method stub
                super.endElement(uri, localName, qName);
            }

            @Override
            public void startElement(String uri, String localName, String qName, Attributes attributes)
                    throws SAXException {
                if("售价",equals(qName)){
                    isPrice=true;
                    count++;
                }
            }    
        });
        reader.parse("book.xml");

    }

@Test
    public void saxParse2list() {
        SAXParserFactory parserFactory=SAXParserFactory.newInstance();
        SAXParser parser=parserFactory.newSAXParser();
        XmlReader reader=parser.getXMLReader();
        reader.setContentHandler(new DefaultHandler(){
            ArrayList<Book>bookshelf=null;
            Book book=null;
            String tag=null;

            @Override
            public void characters(char[] ch, int start, int length) throws SAXException {
                if ("书名".equals(tag)) {
                    book.setTitle(new String(ch, start, length));
                }else if ("作者".equals(tag)) {
                    book.setAuther(new String(ch, start, length));
                }else if ("售价".equals(tag)) {
                    book.setPrice(new String(ch, start, length));
                }
            }
             @Override
            public void endElement(String uri, String localName, String qName) throws SAXException {
                //每次走到结束标签，就要把tag标签结束
                tag=null;
                if ("书架".equals(qName)) {
                   for(Book book1:bookshelf){
                       System.out.println(book1);
                   }
                }else if ("书".equals(qName)) {
                    //读到书结束标签 把book对象添加到集合中
                    bookshelf.add(book);
                }
            }
             @Override
            public void startElement(String uri, String localName, String qName, Attributes attributes)
                    throws SAXException {
                if ("书架".equals(qName)) {
                    //创建集合
                    bookshelf=new ArrayList<Book>();
                }else if ("书".equals(qName)) {
                    book=new Book();
}else if ("书名".equals(qName)) {
                    tag="书名";
                }else if ("作者".equals(qName)) {
                    tag="作者";
                }else if ("售价".equals(qName)) {
                    tag="售价";
                }
            }    
        });    
        reader.parse("book.xml");
    }

import java.awt.print.Book;
import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;

public class PullParserTest {
    @Test
    public void pullTest() throws Exception{
        ArrayList<Book> books=null;
        Book book=null;
        boolean flag=true;
        //获取工厂
        XmlPullParserFactory parserFactory=XmlPullParseFactory.newInstance();
        //获取到xml的解析器
        XmlPullParser parser=PullParseFactory.newPullParser();
        //给解析器设置一个输入源
        //第一个参数输入流 第二个参数是文档用到的字符输入流
        parser.setInput(new FileInputStream(new File("book.xml")),"utf-8");
        //获取当前事件类型
        int eventType=parser.getEventType();
        while (eventType!=XMLPullParser.END_DOCUMENT) {
            switch (eventType) {
            case XmlPullParser.START_TAG:
            //开始标签    
                //parser.getName()获取当前事件对应的元素名字
                if("书架".equals(parser.getName())){
                    //创建一个集合
                    books=new ArrayList<Book>();
                }else if("书".equals(parser.getName())){
                    //创建一个book对象
                    book=new Book(); 
                }else if("书名".equals(parser.getName())){
                    //给book对象设置书名的属性
                    book.setTitle (parser.nextText());//parser.nextText()获取当前节点的下一个文本内容
                }else if("作者".equals(parser.getName())){
                    //给book对象设置作者的属性
                    book.setAuthor(parser.nextText());
                }else if("售价".equals(parser.getName())){
                    //给book对象设置售价的属性
                    book.setPrice(parser.nextText()); 
                }
                break;
            case XmlPullParser.END_TAG:
            //结束标签
                if("书".equals(parser.getName())){
                    //把book对象添加到集合中
                    books.add(book);
                    flag=false;
                }
            default:
                break;
            }        
            //调用parser.next方法解析下一个元素 用这个结果来更新eventtype,如果解析到文档结束，那么就会退出循环
            //如果不更新，就会是死循环了
            eventType=parser.next();
            
        }
        //遍历集合
        for (Book book1:books) {
            System.out.println(book1);
        }
    }
}

package com.dhy.json;

import org.junit.Test;

public class JsonParseDeno {
    @Test
    public void jsonTest(){
        String jString="{"name":"张三","age":"20"}";
        //通过一个具有json格式的字符串就可以创建一个json对象
        JSONObject jb=new JSONObject(srting);
        //获取json对象之后 就可以通过key去取值，根据需求选择相应的getXXX方法
        //可以获取的数据类型 string int long double boolean object
        String name=Obj.getString("name");
        int age=Obj.getInt("age");
        System.out.println("名字"+name+"age"+age);
        
        String jsonArray="[{"name":"张三","age":"20"},"{"name":"李四","age":"22"}]";
        //根据一个具有json数组格式的字符串 创建一个json数组对象
        JSONArray array=new JSONArray(jsonArray);
        for (int i = 0; i < array.length(); i++) {
            //根据索引 取出每一个jsonobject
            jsonArray jsonObject=array.getJSONObject(i);
            name=jsonObject.getString("name");
            System.out.println(name);
        }
    }
}