Java入门15 -- Tree

最新推荐文章于 2021-02-23 09:53:23 发布

oifengo

最新推荐文章于 2021-02-23 09:53:23 发布

阅读量282

点赞数 5

分类专栏： Java入门

本文链接：https://blog.csdn.net/weixin_39381833/article/details/85223625

版权

Java入门专栏收录该内容

37 篇文章 4 订阅

订阅专栏

d12

Map　实现年级班级学生表

Student.java

public class Student {
    private int age;
    private int height;
    private int weight;

    public Student( int height, int weight,int age) {
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public int hashCode() {
        return this.height | this.weight << 8 | this.age << 16;
    }

    public boolean equals(Object obj){
        if(obj == null) return false;
        if(obj == this) return true;
        if(obj instanceof Student){
            return this.hashCode() == obj.hashCode();
        }
        return false;
    }
}

MapＮesteDemo.java

import java.util.HashMap;
import java.util.Map;

public class MapNesteDemo {
    public static void main(String[] args) {
        //学生集合
        Map<String,String> names = null;
        //班级集合
        Map<String,Map<String,String>> classes = null;
        //初始化年级集合
        Map<String,Map<String,Map<String,String>>> grades = new HashMap<String, Map<String, Map<String, String>>>();
        for(int i = 1 ; i <= 3 ; i ++){
            classes = new HashMap<String, Map<String, String>>();
            grades.put(i + "年级",classes);
            for(int j = 1; j <= 2; j ++){
                //创建名单集合－－－－一个班
                names = new HashMap<String, String>();
                classes.put (i +"年级"+ j + "班" , names);

                for(int k = 1; k <= 5 ; k++){
                    names.put("No" + i + "-" + j + "-" + k,"tom" +(k ++));
                }
            }
        }
        //迭代输出
        for(Map.Entry<String,Map<String,Map<String,String>>> entry:grades.entrySet()){
            //年级名称
            String key = entry.getKey();
            //班级集合
            Map<String,Map<String,String>> classes0 = entry.getValue();
            //先输出年级名称
            System.out.println(key);

            //年级内的每个班
            for(Map.Entry<String,Map<String,String>> e:classes0.entrySet()) {


                //班级名称
                String className = e.getKey();
                //名单集合
                Map<String, String> v = e.getValue();
                System.out.println("\t" + className);

            //名单集合
            for(Map.Entry<String,String> e2  : v.entrySet()) {
                String stuNo = e2.getKey();
                String stuName = e2.getValue();
                System.out.println("\t\t" + stuNo + " - " + stuName);
            }
            }
        }

    }
}

在这里插入图片描述

集合框架中常用的接口

Collection接口中有两个子接口
List

可以存放重复元素，元素的存放是有序的

Set

不可以存放重复的元素，元素的存放是无序的
先判断Hashcode 是否相同，如果不同，可以存放，如果相同，再判断是否是同一个对象＝＝
若是同一个对象，视为重复，
在判断equals方法是否相同

this,hash == obj,hash && (this == pbj || this.equals(obj))

List接口中常用的类

Vector　向量

线程安全，但是速度慢，被ArrayList替代

ArrayList

线程不安全，查询速度快

LinkedList

链表结构，增删速度快

取出List集合中的方式

get(int index ):脚标获取元素
iterator():迭代方法获取迭代对象

Set

Hashset,底层用的就是hashmap

Map

Hashmap

Set接口中常用的类

ＨashSet

线程不安全，存取速度快

Ｓｅｔ集合元素唯一性原因

HashSet:通过hashCode()方法　＝＝　equals()方法来保证元素是否相同

TreeSet 有序　Comparable{0<0 >0 }
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
排序实现方式
１．实现Comparable接口，interface Comparable{ int compare(T t){…}}
2. Comparator,对比器
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

通过compare To 或者compare方法中的来保证元素的唯一性，
元素是以二叉树存放的

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

Eclipse&Myeclipse
由于Myeclipse是基于Eclipse上进行开发，因而eclipse的快捷键在Myeclipse也适用。下面我们来看看Eclipse的快捷键。

Ctrl+鼠标左键，这个常用语查看变量、类型及方法的定义以及查看方法的实现
Ctrl+O，这个用于查看一个类的纲要，列出其方法和成员变量，再按一次时，列出该类继承的方法及变量。
Ctrl+T，这个用于查看一个类的继承关系树，是自顶向下的结构显示，再按一次会变成自底向上，同时列出所实现的接口；当这个快捷键使用在方法上时，会列出有同名方法的父类、子类和接口。
Alt+左右方向键，阅读代码时，我们经常进入调用的方法查看后又跳转回调用的位置，Ctrl+左方向键是退回上一个阅读的位置，Ctrl+右方向键是前进到下一个阅读的位置。
Ctrl+Alt+H，这个用于显示方法被哪些方法调用，并生成调用树。
Ctrl+L，这个用于跳转到指定的行

Intellij Idea
Ctrl+鼠标左键，这个常用语查看变量、类型及方法的定义以及查看方法的实现
Ctrl+F12，这个用于查看一个文件的结构。
Ctrl+T，这个用于查看一个类的继承关系树，是自顶向下的结构显示，也可以点击相应的按钮变成自底向上
Alt+左右方向键，阅读代码时，我们经常进入调用的方法查看后又跳转回调用的位置，Ctrl+左方向键是退回上一个阅读的位置，Ctrl+右方向键是前进到下一个阅读的位置。
Ctrl+Alt+H，这个用于显示方法被哪些方法调用，并生成调用树

=====================================

Comparator

java中extends与implements的区别

Map集合常用类

Hashtable

线程安全，速度慢，不允许存放null键，null值，已经被HashMap替代

HashMap

线程不安全，速度快，允许存放null键值对

TreeMap

对键值对进行排序，排序原理与TreeSet相同

**　**

import java.util.Comparator;

public class PersonComparator implements Comparator<Person> {
    public static void main(String[] args) {

    }
//自定义对比器
    public int compare(Person o1,Person o2){
        if(o1 == null){
            if(o2 == null){
                return 0;
            }
            else{
                return -1 ;
            }
        }
        else {
            if(o2 == null){
                return 1;
            }
            else {
                return o1.getHeight() - o2.getHeight();
            }
        }
    }


}

Map与Collection

 - Map与Collection在集合中是并存的
 - Map存储的是键值对
 - Map存储元素使用的是put方法，Collection使用的是add方法
 - Map集合没有直接取出元素的方法，而是先转换为Set集合，再通过迭代获取元素
 - Map集合中键要保证唯一性

集合框架中常用的工具类

Collections

对集合进行查找
取出集合中的最大值，最小值
对List集合进行排序

Arrays

将数组转换成List集合
对数组进行排序
对数组进行二分查找

ＣollectionToolDemo.java

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

public class CollectionToolDemo {
    public static void main(String[] args) {
        int[] src = {1,2,3,4};
        int[] dest = new int[6];
        System.arraycopy(src,1,dest,2,3);

        Person[] src0 = {new Person(100),new Person(200),new Person(300),new Person(400)};
        Person[] dest0 = new Person[6];

        //拷贝数组
        System.arraycopy(src0,1,dest0,2,3);
        //
        src[2] = 1000;
        System.out.println(dest[3]);

        src0[2].setHeight(1000);
        System.out.println(dest0[3].getHeight());

        //得到同步集合
        List<String> names = Collections.synchronizedList(new ArrayList<String>());
        names.add("tom");
        names.add("tom");
        names.add("tom");
        names.add("tom");
        names.add("tom");
        System.out.println(names.size());

        System.out.println("====================");
        //asList将参数转换成Ａrray$ArrayList集合对象
        List list = Arrays.asList(1,2,3,4);
        System.out.println(list.size());
        //排序
        //Arrays.sort();
    }
}

在这里插入图片描述
ProForDemo.java

import java.util.ArrayList;
import java.util.List;

public class ProForDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        //对数组进行for循环
        for(int i : arr){
            System.out.println(i);
        }
        //List Set Map.entrySet|Map.keySet
        List<String> list = new ArrayList<String>();
        list.add("tom");
        list.add("tom");
        list.add("tom");
        list.add("tom");
        list.add("tom");
        //对集合ｆｏｒ循环
        for(String s :list){
            System.out.println(s);
        }


    }
}

在这里插入图片描述
增强for语句

Collection在JDK1.5后出现的父接口
Iterable就是提供了这个For语句

格式

for(数据类型　变量名：数组或Collection集合)
｛
	执行语句;
	｝

addTels(String s1 , String … str);

变长参数必须是方法的最后一个参数

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

Input / Output

输入输出
stream　流
流的类型：

字符流　操纵文本的 Reader | Writer
字节流　二进制文件　byte　InputSteam | OutSteam

流向：

输入流：读操作
输出流：写操作

IO流常用基类

字节流的抽象基类

InputStream
OutputStream

字符流的抽象基类

Reader
Writer

这四个类派生出来的子类名称都是以其父类名作为子类的后缀

InputStream的子类FileInputStream
Reader的子类FileReader
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

字符流　创建文件

创建流对象　建立数据存放文件

FileWriter fw = new FileWriter("Test.txt");

调用流对象的写入方法，将数据写入流

fw.writer("text");

关闭流资源，并将流中的数据清空到文件中

fw.close();

import java.io.FileWriter;
import java.io.IOException;

public class FileWriteDemo {
    public static void main(String[] args) {
        try {
            FileWriter write = new FileWriter("/media/ifeng/_dde_data/iotest/hello.txt");
            System.out.println("=========");
            write.write("hello world");
            write.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

writer.close()的作用

    public void close() throws IOException {
        this.se.close();
    }

public class OutputStreamWriter extends Writer {
    private final StreamEncoder se;

    public OutputStreamWriter(OutputStream var1, String var2) throws UnsupportedEncodingException {
        super(var1);
        if (var2 == null) {
            throw new NullPointerException("charsetName");
        } else {
            this.se = StreamEncoder.forOutputStreamWriter(var1, this, var2);
        }
    }

flush

清理，将文件推送到目标设备上去，没有有清理前，文件一直在内存中

    public void flush() throws IOException {
        this.se.flush();
    }

refresh

刷新

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
close自动调用flush，只调用flush也可以写入
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

            FileWriter write = new FileWriter("/media/ifeng/_dde_data/iotest/hello2.txt");
            System.out.println("=========");
            write.write("hello world");
            write.flush();
            //write.close();

在这里插入图片描述

java.io.FileWriter

new FileWriter(String path);
write(String str);写入的字符数据到流中
flush( ) 清理流　将流中的数据写入目标设备中
close( ) 隐含了flush()操作，在close()时会进行一次flush(),关闭后不能再写入，重复关闭不会有问题

            FileWriter write = new FileWriter("/media/ifeng/_dde_data/iotest/hello2.txt");
            System.out.println("=========");
            write.write("hello world");
            //write.flush();
            write.close();
            write.write("hello world22");

在这里插入图片描述

注意：无论如何都应该把流关掉
FileWriter 定义在外面
close在finall{ }中
在这里插入图片描述

import java.io.FileWriter;
import java.io.IOException;

public class FileWriteDemo {
    public static void main(String[] args) throws IOException {
        FileWriter write = null;
        try {
            write = new FileWriter("/media/ifeng/_dde_data/iotest/hello2.txt");
            System.out.println("=========");
            write.write("hello world");
            //write.flush();
            write.write("hello world22");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(write != null){

                write.close();
                write.close();
            }
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊　＊
　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

字符流－－读取文件

建立一个流对象，将已存在的一个文件加载进流

FileReader fr = new FileReader("Test.txt");

创建一个临时存放数据的数组

char [ ] ch= new char[1024];

调用流对象的读取方法将流中的数据读入到数组中

fr.read(ch);

－－－－－－－－－－－－－－－－－－－

try catch finally快捷键：ctrl + Alt + T

－－－－－－－－－－－－－－－－－－－

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader reader = null;
        try {
            reader = new FileReader("/media/ifeng/_dde_data/iotest/hello2.txt");
            char[ ] buffer = new char[3];

            while (true){
                int length = reader.read(buffer);
                //到达流末尾
                if(length == -1){
                    break;
                }
                else {
                    System.out.print(new String(buffer,0,length));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(reader != null){

            }
        }

    }
}

在这里插入图片描述

常用的文件读方法
定义len = -1

            int len = -1;
            while ((len = reader.read(buffer)) != -1){
                System.out.print(new String(buffer,0,len));
            }
            System.out.println("=================");

oifengo

关注

5
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java入门15 -- Tree

Map　实现年级班级学生表Student.javapublic class Student { private int age; private int height; private int weight; public Student( int height, int weight,int age) { this.age = age; ...
复制链接

扫一扫