前言

设定目标，收集资料，分析问题，归纳总结

参考资料

java基本数据类型：www.runoob.com/java/java-b…
java自动装箱与拆箱：blog.csdn.net/ZD688/artic…
字符编码由来：blog.csdn.net/duduniao999…
java创建数组的几种方式：blog.csdn.net/SDDDDDSA/ar…
Comparable和Comparator 两个接口的区别：wenku.baidu.com/view/e94789…
Java之数组查询Arrays类的binarySearch()方法详解：blog.csdn.net/qq_43460335…
java中数组删除其中的元素：www.csdn.net/tags/Mtzacg…
java中数组元素的移动：www.bilibili.com/video/BV1g3…
数据结构链表篇：blog.csdn.net/qq_16268979…
LinkedList的实现：blog.csdn.net/qq_39225639…
Java数据结构之链表及实现:blog.csdn.net/weixin_4372…
链表的定义：blog.csdn.net/qq_42759112…
LinkedList相关知识及底层链表实现原理：blog.csdn.net/qq_35006660…
LinkedList用作栈和队列：blog.csdn.net/weixin_4369…
参考书籍《Java8实战——中国工信出版集团》
参考代码链接：github.com/java8/Java8…
Lambda表达式的几种语法:blog.csdn.net/guzhaocong/…

确认目标

通过一些常见的普通数据学习延伸至一些高级数据应用，然后通过应用发现本质原理，这是一个长期的过程，需要不断的深入学习数据处理的方法；

分析过程

语言的逻辑架构：普通数据->高级数据->数据的应用->数据的本质

自我总结

引用百度百科一段话，数据（data）是事实或观察的结果，是对客观事物的逻辑归纳，是用于表示客观事物的未经加工的原始素材。而在生活中总是将有些具有相同属性的事物喜欢归类，将他们以某种类型进行划分，其实数据也是如此，对于复杂的事物或者事件，采用一种数据，肯定是无法表达；而数据的划分，又将定义数据的类型；那么需要学习一下基本数据类型；参考上述链接即可。只是需要重点把握的是，数据之间的联系与转换，以及java中自动拆箱与装箱（blog.csdn.net/ZD688/artic…
```
低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double 
```
除了数据类型之外，当遇到一些群体数据分析时，就需要定义一些数据结构来表达了群体；例如一个教室能容纳的学生，学生有很多，学生有学号，比如统计学生的学习成绩，按照成绩来选座位的问题；将这类问题，通过量化为数据，然后通过一些数学方法就可以解决了。那么表达群体数据时有哪些呢？线性结构与非线性结构；
我们先研究线性结构中的基本群体数据构体：数组；那么如何来学习数组呢？我先把数组当成一个工具，生活中既然是工具，先使用这个工具之后，再来透过思考本质；既然当成工具，来就需要具有这个工具吧，那就先创建工具，也就是创建数组？至于如何创建数组，数组有哪些创建方式，可以参考链接即可；有了数组之后，就需要看一下具体就看下数组能有哪些操作？如：将你创建的数组进行排序，查询数组中的元素，删除数组中的元素，修改数组中的元素，向数组中添加元素，将数组的中的元素进行互换，将数组中元素进行过滤和拆分，将数组的元素进行移动，将数组转换为集合。
那么下面例子一一介绍操作：
排序

//        定义数组
        int[] test = {9, 32, 23, 87, 2};
//        打印数组
        System.out.println(Arrays.toString(test));
//        输出结果：[9, 23, 32, 87, 2]
//        对数组进行排序操作并输出排序后的操作,默认是升序
        Arrays.sort(test);
        System.out.println(Arrays.toString(test));
        Integer[] b = {2, 233, 543, 0, 21};
//        对数组进行降序排序操作 可以使用Comparator.reverseOrder()，但是需要将使用包装类型的进行排序，
//        当然也可以自己去实现Comparator接口
        Arrays.sort(b, Comparator.reverseOrder());
        System.out.println(Arrays.toString(b));
//        如果想对基本数据类型进行降序输出，可以采用从尾部到前面进行循环遍历即可
//        对数组中部分元素按照升序进行排序,从下标为0的元素，选择前3个元素进行排序
        int[] test1 = {9, 32, 23, 87, 2};
        Arrays.sort(test1, 0, 3);
        System.out.println(Arrays.toString(test1));

查询

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        对数组进行升序排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
//        查询3是否所处数组的位置
        int i = Arrays.binarySearch(a, 0);
        System.out.println(i);
        更多关于binarySearch参考上述链接

删除

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        删除数组中的元素,例如删除3这个元素
        int[] b = new int[a.length - 1];
        for (int i = 0, k = 0; i < a.length; i++) {
            if (a[i] != 3) {
                b[k] = a[i];
                ++k;
            }
        }
        System.out.println(Arrays.toString(b));

修改

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        元素的中3修改为5
        a[0] = 5;
        System.out.println(Arrays.toString(a));
//        将数组中0元素修改为3
        Arrays.sort(a);
        int i = Arrays.binarySearch(a, 0);
        if (i >=0) {
            a[i]=3;
        }
        System.out.println(Arrays.toString(a));
    }

添加

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        将7添加到数组中
        int[] b = new int[a.length + 1];
        System.arraycopy(a, 0, b, 0, a.length);
        b[b.length - 1] = 7;
        System.out.println(Arrays.toString(b));

交换

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        将数组中第二个元素与第5个元素交换位置
        int c = a[1];
        a[1] = a[4];
        a[4] = c;
        System.out.println(Arrays.toString(a));

分割

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        将取数组中前3个元素并输出
        int[] ints = Arrays.copyOf(a, 2);
        System.out.println(Arrays.toString(ints));
//        取数组中1-4给元素并输出
        int[] ints1 = Arrays.copyOfRange(a, 1, 4);
        System.out.println(Arrays.toString(ints1));

过滤

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        选出大于9的元素并输出
        List<Integer> b = new ArrayList<>();
        for (int value : a) {
            b.add(value);
        }
        List<Integer> collect = b.stream().filter(x -> x > 9).collect(Collectors.toList());
        System.out.println(collect);

移动

//        定义数组
        int[] a = new int[]{3, 456, 567, 8, 9, 0};
//        赋值式移动
//        将第一个位置进行移动到第最后一个位置，其他元素也都进行移动
        int x = a[0];
        for (int i = 1; i < a.length; i++) {
            a[i - 1] = a[i];
        }
        a[a.length - 1] = x;
        System.out.println(Arrays.toString(a));
//        将第二个位置进行移动一位
        int[] t = new int[]{3, 932, 567, 8, 9, 0};
        int k = 2;
        for (int i = 0; i < k; i++) {
            int s = t[0];
            for (int j = 1; j < t.length; j++) {
                t[j - 1] = t[j];
            }
            t[t.length - 1] = s;
        }
        System.out.println(Arrays.toString(t));
//        交换式移动：将数组逆置输出
        int[] b = new int[]{4, 5, 69, 60, 1};
        for (int i = 0; i < b.length / 2 - 1; i++) {
            int c = b[i];
            b[i] = b[b.length - 1 - i];
            b[b.length - 1 - i] = c;
        }
        System.out.println(Arrays.toString(b));

        //不找i与j之间的存在的数学关系，只存在区间的关系
        int[] z = new int[]{9, 3, 4, 5, 0};
        for (int i = 0, j = z.length - 1; i < j; i++, j--) {
            int y = z[i];
            z[i] = z[j];
            z[j] = y;
        }
        System.out.println(Arrays.toString(z));
    }

转换

//        定义数组
        Integer[] a = new Integer[]{3, 456, 567, 8, 9, 0};
        System.out.println(Arrays.asList(a));

从上述看，数组的添加和删除都需要创建一个新的数组，来存放新的数据，那么数组就发生了变化，其效率性能上就降低了，那么为了解决这个问题，引入新的数据结构：链表（至于排序算法，查询算法操作，自行百度，刷题吧）; 还是看一下链表的定义，链表有哪些操作：创建、查询、新增、删除、修改、移动

定义：链表是一种物理存储单元上非连续、非顺序的存储结构，由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成
创建：从概念得知，链表其实就是一系列的节点组成，创建链表之前，首先应创建节点对象，而节点对象包含有具体元素的值，以及下一个节点的引用；

public class Node<T> {
    private T item;
    private Node<T> next;

    public Node(T item, Node<T> next) {
        this.item = item;
        this.next = next;
    }

    public static void main(String[] args) {
        //创建结点
        Node<Integer> node1 = new Node<>(2, null);
        Node<Integer> node2 = new Node<>(3, null);
        Node<Integer> node3 = new Node<>(4, null);
        Node<Integer> node4 = new Node<>(5, null);
        //生成一个链表
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
    }
}

查询、新增、删除、修改链表的操作通过LinkedList集合源码分析来讲述 transient关键字的作用是:被transient修饰的变量不参与序列化和反序列化

    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        //元素的添加
        linkedList.add(1);
        //元素的删除
        Integer remove = linkedList.remove(0);
//        返回移除的元素信息
        System.out.println(remove);
        linkedList.add(1);
//      元素的查询链表所在的下标
        int i = linkedList.indexOf(1);
        System.out.println(i);
//       元素的修改,返回修改前的元素的值
        Integer set = linkedList.set(0, 2);
        System.out.println(set);
//        输出列表信息
        System.out.println(linkedList);
    }

除了上述操作外，查看源码，linkedList可以被当做队列和栈来使用的，详细参考上述链接

//        将linkedList当做队列来使用，从队尾插入，从队首取出
        Deque<Integer> e = new LinkedList<Integer>();
        e.offer(1);
        e.offer(2);
        Integer poll = e.poll();
        System.out.println(poll);
        System.out.println(e);
//        将linkedList当做栈来使用，向栈中添加元素，想栈顶取出元素
        Deque<Integer> c = new LinkedList<Integer>();
        c.push(1);
        c.push(2);
        Integer pop = c.pop();
        System.out.println(pop);
        System.out.println(c);

在这里由基本类型的数组慢慢的就迁移到了另外一层，就是集合方面概念，而尝尝在项目过程中使用集合操作，查找，遍历，删除，过滤，筛选，常见集合的操作，基本上可以引入一些java8的特性来操作集合；所以接下来就看一下使用java8来对群体数据操作的案例；而Java8首先应该理解lambda，参考上述连接即可。

过滤：关键字filter
排序：关键字sort
提取：关键字map
截取：关键字limit
收集：关键字collect
去重：关键字distinct
统计：关键字count
跳过：关键字skip
判断：接口终端操作关键字anyMatch匹配任意一个,allMatch所有匹配,noneMatch所有都不匹配
归约汇总：关键字reducing 最后常在项目中进行数据处理时，联想用流来进行处理数据吧。

一起来认识Java中的数据

前言

参考资料

确认目标

分析过程

自我总结