Java 数据结构源码及源码 java数据结构是什么

1.数据结构　

　　数据结构是计算机存储、组织数据的方式。
　　数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。

2.分类

　　集合 set

　　线性结构 array、list、map

　　树形结构 Jtree

　　图形结构 无

一下导入的都是import java.util.XXX

3.[引用数据类型]数组  Array

　　数组是一中数据结构，是一个容器，它用来盛放数据，不同类型的数组可以盛放不同类型的数据；

　　特点：数组的容量收拾确定的，就是必须执行数组的大小；

　　　　　数组的类型是确定的，就是在定义数组的时候不许指定数组的类型，一种类型的数组只能是一种类型的数据

     需要掌握二维数组

　　在 Java 中提供有一种动态取得数组长度的方式：数组名称.length；

　　使用：定义——初始化——添加元素——遍历

添加数据:
    （方式1）
    定义      int[] arr1 = new int[100];        //定义一个可以存100个整数的数组，长度固定
    写入      for (int i = 0; i < 100; i++) {    //给数组10个下标对应存储单元，赋100个值
                //该方法可以随时修改某一个下标的值
                arr1[i] = i;
              }
    
    （方式2）
    定义      int[] arr2 = { 1, 2, 3, 5, 4, 6, 9, 7, 8, 0 };
                //定义一个可以存10个整数的数组，并且完成赋值。

    使用      int b=arr1[3];    //获取下标为3的数组单元存储的值

    
    遍历数据:
    (方式1)
     for (int i = 0; i < arr2.length; i++) {
                //从下标0开始，输出数组的10个值
                System.out.print(arr2[i] + ",");
              }
    
    (方式2)
    for (int j : arr2) {
                //从下标0开始，输出数组的100个值
                System.out.print(j + ",");
              }

View Code

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String name1 = "大狗";
        String name2 = "胖虎";
        String name3 = "睿";
        // 假设班上有100位同学: 在java里面 我们可以用 数组 Array .
        String[] arrayNames = new String[100];// 定义数组的第一种方式
        String[] arrayNames1 = { "大狗", "胖虎", "睿" };// 定义数组的第二种方式
        // System.out.println(arrayNames1[2]);//索引取值
        System.out.println(arrayNames.length);// 获取数组的长度
        arrayNames[0] = "大狗";//添加元素，再次使用该索引的时候就是修改元素
        System.out.println(arrayNames[0]);
        for (int i = 0; i < arrayNames.length; i++) {
            // System.out.println(i);
            arrayNames[i] = "大狗" + i;//循环赋值
        }
        for (int i = 0; i < arrayNames.length; i++) {
            String name = arrayNames[i];
            // System.out.println(i);
            System.out.println(name);//前面赋值了，这里是循环输出值
        }

        // 第二种方式  遍历循环结构...
        // String name . 定义了一个名字为name 的 字符串 .. 它会循环接收 数组中遍历出来的数据..
        for (String name : arrayNames) {
            System.out.println(name);
        }

    }

View Code

String [][] names2= {{"肖战","小飞侠"},{"仝卓"},{"金瀚","王一博"}};
    for (String[] strings : names2) {//直接打fore就出来啦
        System.out.println(strings);
    }

View Code

二维数组：

　　内部元素仍然是一维数组的数组（数组的内部不是单个的数据，而是一维数组）

　　创建方式和一维数组一样。[针对标准的二维数组]有几个一维数组就有几行，每个一维数组有几个元素就有几列。当然一维数组中的元素个数不一样那就不是了。

//一维数组
//没有初始化数组的元素  int类型的数组默认值为0，所以此数组中有5个0
    int [] arr1=new int[4];//int是类型  4是容量（长度）
//已知数组的内部元素
    String [] names= {"肖战","王一博","金瀚"};
//索引（下标）取值
    System.out.println(names[0]);
    System.out.println("华丽分割线============下面是二维数组取值=============");
//二维数组
    String [][] names2= {{"肖战","小飞侠"},{"仝卓"},{"金瀚","王一博"}};
    String [][]    names3=new String[4][3];//4行3列
    //取出地一样第一列的值
    System.out.println(names2[0][1]);

View Code

4.set 集合（接口类）——元素不能重复并且无序（刚好和list相反）

　　容器支持的数据类型：引用类型

　　添加数据的时候，回去比较hashCode值，如果一样就不继续添加相同的；

　　可以去重

　　集合中的元素不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。对Set中成员,不能有重复对象。

　　使用：定义——初始化——添加/删除元素——遍历

public static void main(String[] args) {//需要导入包，但是eclipse会有提示
        Set<String> setNames = new HashSet<String>();//定义set
        setNames.add("大狗");//set添加元素并且元素不能重复,有重复的在遍历的时候也只会输出相同的一个
        setNames.add("睿");
        setNames.add("胖虎");
        setNames.add("大狗");
        setNames.add("二娃子");
        System.out.println(setNames.contains("睿"));//判断set是否包含
        setNames.remove("睿");//移除元素
        System.out.println(setNames.contains("睿"));
        for (String name : setNames) {//循环遍历集合
            System.out.println(name);
        }
    }

View Code

package list_map_set;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetLearning {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashSet<String> set = new HashSet<String>();
        System.out.println(set.size());
        System.out.println(set.isEmpty());
        set.add("肖战");
        set.add("魏无羡");
        set.add("蓝忘机");
        set.add("蓝思追");
        System.out.println(set.size());//验证是否可以有相同的数据
        set.add("肖战");
        System.out.println(set.size());
        System.out.println(set.contains("肖战"));
        System.out.println(set.remove("蓝思追"));
        System.out.println("+++++++++++++++华丽分割线++++++++++");
        //直接增强for循环三种方式
        for (String names : set) {
            System.out.println(names);
        }
        System.out.println("+++++++++++++++华丽分割线++++++++++");
        // 转换成为数组再遍历
        Object[] objects = set.toArray();
        for (Object obj : objects) {
            System.out.println(obj);
        }
        System.out.println("+++++++++++++++华丽分割线++++++++++");
//    set.clear();//删除set里面的所有数据
//    System.out.println(set.size());
        // 迭代遍历set集合
        Iterator<String> ite = set.iterator();
        while (ite.hasNext()) {// 判断是否有下一个
            System.out.println(ite.next());
        }

    }

}

View Code

5.链表　（接口类）

ArrayList接口及其实现类是容量可变的列表，可按索引访问集合中的元素。
集合中的元素可重复并且有序。

容器支持的数据类型：引用类型

　　使用：定义——初始化——添加/删除元素——遍历

public static void main(String[] args) {//长度没有定义，长度可以随时变化
        List<String> listNames = new ArrayList<String>();
        listNames.add("大狗");//往list中添加元素
        listNames.add("睿");
        listNames.add("胖虎");
        listNames.add("大狗");

        // System.out.println(listNames.get(0));//genuine索引取值
        listNames.add(2, "胖虎1");//在列表下标为2的位置添加一个元素，原来下标为2和以后的元素后移
        System.out.println("插入数据:" + listNames.get(2));
        listNames.set(2, "555");////把列表中下标为2的位置存放的值，重新赋值为555
        for (int i = 0; i < listNames.size(); i++) {//循环遍历
            String name = listNames.get(i);
            // System.out.println(i);
            System.out.println(name);
        }
//        for (String name : listNames) {
//            System.out.println(name);
//        }
    }

插入数据:胖虎1
大狗
睿
555
胖虎
大狗

View Code

package list_map_set;

import java.util.ArrayList;
import java.util.Iterator;

/*基本数据类型对应的包装类型（专业说法）
 *boolean:Boolean
 *byte:Byte
 *short:Short
 *int:Integer
 *long:Long
 *float:Float
 *double:Double 
 * char:Character
 * */
public class ListLearning {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();// <数据类型>
        System.out.println(list.size());// 获取结合的大小
        list.add("肖战");// 添加属性
        list.add("王一博");
        list.add("金瀚");
        System.out.println(list.size());// alt+方向键代码会向上或者向下移动
        System.out.println(list.get(1));// 获取元素
        System.out.println(list.remove(0));// 删除指定索引对应的值 返回的即使移除掉的元素 python 中列表的pop()方法同理
        System.out.println(list.remove("王一博"));// 参数类型不一样 Java重载 object顶级父类 返回true或者false
        System.out.println(list.isEmpty());// 判断是否为空 返回boolean
        System.out.println(list.contains("温宁"));// 判断是否包含 返回boolean
        list.set(0, "没有秘密的你");// 修改数据
        System.out.println(list.get(0));
        list.add("陈情令");
        System.out.println("=========华丽分割线，下面是for循环========");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("=========华丽分割线，下面是增强for循环========");
        for (String names : list) {// 增强for循环
            System.out.println(names);
        }
        System.out.println("=========华丽分割线，下面是通过迭代器遍历========");
        // 迭代器
        Iterator<String> ite = list.iterator();
        while (ite.hasNext()) {
            System.out.println(ite.next());
        }

    }

}

View Code

6.字典（接口类）　　

　　Map是一种把键对象和值对象进行关联的容器。
　　特点：key不允许重复。key-value，重复时，后面键值对覆盖前者

　　键和值支持的数据类型：

　　　　引用类型

　　使用：定义——初始化——添加/删除元素——遍历

public static void main(String[] args) {
        // 定义一个字典. key是班级名字. value 是班级的别名.. key的类型一定是String
        Map<String, String> classmap = new HashMap<String, String>();
        // 第一次put 是添加
        classmap.put("1912", "Java大佬");
        classmap.put("1913", "250班");

        // 第二次put 就是修改..
        classmap.put("1912", "Java大佬班");
        System.out.println(classmap.get("1912"));//取值
        for (String key : classmap.keySet()) {
            // 遍历key，通过key获取value
            System.out.println(classmap.get(key));
        }
        System.out.println("华丽分割线====================================");
        for (Entry<String, String> entry : classmap.entrySet()) {
            // 定义一个map的入口，通过入口一个个遍历map里面的元素和值
            entry.getKey();
            entry.getValue();
            System.out.println(entry.getKey() + "=" + entry.getValue() + "; ");
        }
    }


Java大佬班
250班
Java大佬班
华丽分割线====================================
1913=250班; 
1912=Java大佬班;

View Code

package list_map_set;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapLearning {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("name", "肖战");// 添加键值对
        map.put("age", "18");
        System.out.println(map.size());// 获取字典的大小
        System.out.println(map.get("name"));// 根据key取值
        // String na = map.remove("name");// 返回的是移除的value
        // System.out.println(na);
        System.out.println(map.containsKey("gender"));// 判断是否包含key，返回布尔值
        System.out.println(map.containsValue("王一博"));// 判断是否包含value，返回boolean
        System.out.println("==========华丽分割线++++++++++++++++++");
        Set<String> keys = map.keySet();// 一次性拿到所有的key
        for (String key : keys) {
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }
        System.out.println("==========华丽分割线++++++++++++++++++");
        Collection<String> values = map.values();// 一次性拿到所有的values
        for (String value : values) {
            System.out.println(value);
        }
        System.out.println("==========华丽分割线++++++++++++++++++");
        // entry 代表一个key-value
        Set<Entry<String, String>> entries = map.entrySet();
        for (Entry<String, String> entry : entries) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

    }

}

View Code

数组转链表：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        //数组转链表
        // 数组
        Integer[] arrayNum = { 1, 2, 3, 5, 4, 6, 9, 7, 8, 0 };

        // 链表
        List<Integer> listNum = new ArrayList<>();

        // 方式1
        for (int i = 0; i < arrayNum.length; i++) {
            listNum.add(arrayNum[i] + 1);
        }

//        //方式2
//        listNum = Arrays.asList(arrayNum);
//        for (Integer i : listNum) {
//            System.out.println(i);
//        }

//        //方式3
//        List<Integer> listNum2 = new ArrayList<>();
//        listNum2.add(55);
//        listNum2.add(100);
//        listNum.addAll(Arrays.asList(arrayNum));
//        
        // System.out.println(listNum);

        // 方式4
//        Collections.addAll(listNum,arrayNum);

        for (Integer i : listNum) {
            System.out.println(i);
        }

        System.out.println("-------------------");

        Integer[] arrayNum2 = new Integer[listNum.size()];
        for (int i = 0; i < listNum.size(); i++) {
            arrayNum2[i] = listNum.get(i);
        }

        for (Integer integer : arrayNum2) {
            System.out.println(integer);
        }

        System.out.println("-------------------");
        int sum = 0;
        for (int i = 0; i < arrayNum2.length; i++) {
            sum += arrayNum[i];
            // sum = sum + arrayNum[i];
        }
        System.out.println("-------------------");
        System.out.println(sum);
    }

View Code

 小练习：在类中定义私有成员属性，然后通过set 和get方法，让外界获取简捷：菜单栏——source——generate getters and setters—勾选——generate，即可快速生成喔

package list_map_set;

public class Student {
    private String name;
    private int age;
    private String gender;

    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;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    public Student() {}
    public Student(String name,int age,String gender) {
        this.name=name;
        this.age=age;
        this.gender=gender;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "姓名："+this.name+",年龄："+this.age+"，性别："+this.gender;
    }
}

View Code

package list_map_set;

import java.util.ArrayList;
import java.util.Iterator;

public class TestStudent {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student student = new Student("肖战", 28, "男");
        Student student1 = new Student("王一博", 22, "男");
        Student student2 = new Student("金瀚", 26, "男");
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(student);
        list.add(student1);
        list.add(student2);
        // list.remove(student2);//移除数据

        // student1=list.get(0);
        // student1.setName("魏无羡");// 修改值

        Student student6 = list.get(0);// 把studengt1的地址给了6 变量都指向同一块内存区域
        student6.setName("魏无羡");
        System.out.println(student1.getName());
        System.out.println(student6.getName());

        System.out.println("==============华丽分割线+++++++++++++++++");
        // 第一种遍历
        for (int i = 0; i < list.size(); i++) {
            Student student4 = list.get(i);
            // 不重写object的toString方法
            // System.out.println("姓名：" + student4.getName() + ",年龄：" + student4.getAge() +
            // ",性别是：" + student4.getGender());

            // 重写之后
            System.out.println(student4.toString());
        }
        System.out.println("==============华丽分割线+++++++++++++++++");
        // 增强for循环
        for (Student student5 : list) {
            System.out.println(student5);
        }
        System.out.println("==============华丽分割线+++++++++++++++++");
        // 迭代器
        Iterator<Student> stud = list.iterator();
        while (stud.hasNext()) {
            Student student7 = stud.next();
            System.out.println(student7);

        }
    }

}

View Code

package list_map_set;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TestStudentClass {
    /*
     * 1.有两个班级，一个是“1801"班， 一个是“1802"班，
     * 
     * “1801"班有三个学生studentA, studentB， studentC,“1802"班有两个学生studentD.
     * studentE.studentA: name-张三，age-25， gender- 男studentB: name-李四，age-26. gender-
     * 男studentC: name-小花，age-27, gender -女studentD: name-小明，age-28，
     * gender-男studentE: name-小红，age-29， gender- 女
     * 
     * 请用map保存好两个班级的学生数据每个班级底下保存对应的学生信息，请思考map集合的键和值应该用什么类型。2.
     * 通过两种循环遍历map集台取出每个班级底下的学员数据。井输出。
     */
    public static void main(String[] args) {
        Map<String, ArrayList<Student>> map = new HashMap<String, ArrayList<Student>>();
        ArrayList<Student> list1 = new ArrayList<Student>();
        Student studentA = new Student("肖战", 28, "男");
        Student studentB = new Student("王一博", 22, "男");
        Student studentC = new Student("金瀚", 26, "男");
        String class1 = "1班";
        list1.add(studentA);
        list1.add(studentB);
        list1.add(studentC);
        map.put(class1, list1);

        ArrayList<Student> list2 = new ArrayList<Student>();
        Student studentD = new Student("杜江", 34, "男");
        Student studentE = new Student("霍思燕", 39, "女");
        String class2 = "2班";
        list2.add(studentD);
        list2.add(studentE);
        map.put(class2, list2);

        // 第一种遍历
        Set<String> classNames = map.keySet();
        for (String classname : classNames) {
            System.out.println("班级名称：" + classname);
            List<Student> list3 = map.get(classname);
            for (Student info : list3) {
                System.out.println(info);

            }

        }
    }
}

View Code

package list_map_set;

public class TestStudentTwo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student student1 = new Student("肖战", 28, "男");
        Student student2=student1;
        student2.setName("魏无羡");
        System.out.println(student1);
        System.out.println(student2);
    }

}
#####################
姓名：魏无羡,年龄：28，性别：男
姓名：魏无羡,年龄：28，性别：男

View Code