java的数组和链表

Posted lw687a

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java的数组和链表相关的知识，希望对你有一定的参考价值。

         数组和链表
              java的数组是什么：数组是用来存放同一种数据类型的集合，

数组中每个元素都是相通的数据类型，数组就是在内存中划分一串连续的空间（数组作为对象允许使用new关键字进行内存分配），注意只能存放同一种数据类型(Object类型数组除外)，数组是一种数据结构

                举个栗子：string：就是char类型的数组。
               为什么要学数组：因为数组可以存放许多相同的数据类型！！编写程序时省去了很多代码量！！
        怎么使用数组：
            第一种方式：

                    数据类型 []  数组名称 = new 数据类型[数组长度];

                    这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面，我们推荐放在数组名称的前面，这样看上去 数据类型 [] 表示的很明显是一个数组类型，而放在数组名称后面，则不是那么直观。
                //声明数组1,声明一个长度为5，只能存放int类型的数据
                int [] a = new int[5];
                System.out.println(a.length);
            第二种方式：
                    数据类型[] 数组名称={数据1，数据2}。
    //声明数组2,声明一个数组元素为 1,2,3,4,5的int类型数组
    int [] b = {1,2,3,4,5};
                System.out.println(b.lengyh);

        访问数组元素以及给数组元素赋值:

               数组是存在下标索引的，通过下标可以获取指定位置的元素，数组小标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。我们在声明数组的同时，也进行了初始化赋值。        

              int[] a={1,2,3};//元素长度为三，超出就会报错

              a[0]=1;//下标为0的值为1

            system.out.println(a[0]);//访问数组的第一个元素

    length：是数组的长度。可以通过数组名.length获取长度

    循环数组

        //声明数组,声明一个数组元素为 1,2,3的int类型数组
        int [] c = {1,2,3};
        for(int i = 0 ; i < c.length ; i++){

            System.out.println(c[i]);

        //循环变量i从0开始递增直到达到数组的最大长度，每次循环加1.。。

            一些练习：

            double[] myList = {1.9, 2.9, 3.4, 3.5};
              // 打印所有数组元素
              for (int a = 0; a < myList.length; a++) {
                 System.out.println(myList[a] + " ");
              }
              // 计算所有元素的总和
              double sum= 0;
              for (int b = 0; b < myList.length; b++) {
                    sum+= myList[b];
              }
              System.out.println("sumis" +sum);
              // 查找最大元素
              double max = myList[0];
              for (int d = 1; d < myList.length; d++) {
                 if (myList[d] > max) 
                     max = myList[d];
              }

              System.out.println("Max is " + max);

数组的排序

语法：Arrays.Sort数组名)

注意：在排序之前加上   Arrays.name(数组名)就可以完成升序排列 了

              int[] a={199,27,31}

                array.sort(a);

                System.out.println("排序后的值");

for (int j = 0; j <a.length; j++) {
                System.out.println(a[j]);
                //可以.tostring方法把数组变成字符串

            }

            多维数组

                多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

                数据类型[][] 数组名;

                数组名=new 数据类型[1][2];

                int[][] a=new int[3][4];//二维数组 a 可以看成一个两行三列的数组。

               赋值：二维数组的赋值，和一维类似，可以通过下标来逐个赋值，   

                举个栗子：           

             int[][] s= new int[2][];
              s[0] = new int[2];
              s[1] = new int[3];
              s[0][0] = 22; 
              s[0][1] = 23;
              s[1][0] = 24; 
              s[1][1] = 25;

              s[1][2] = 26;

数组实现数据结构：

       数据结构的作用：模拟生活中的数据存储；对数据进行增删改查

和数据库的区别
                对该同学信息进行增删改查
                数据库是把数据存到磁盘里面，他支持可调定式
                电脑存数据有两块区域，第一个是硬盘，第二个是内存。硬盘是永久储存，内存是临时的，但是内存数据快。
 通过需求分析 模拟数据存储的案例
        举个栗子：模拟LOL代号的存储，假设我现在是某只战队的教练，我需要安排上场的人员（不要问为什么是LOL，我只玩LOL）
                作为一个教练要安排上场
                        1.初始化容量为5的线性列表，准备用来存储场上的五个代号
                        2.安排人员上场（uzi,looper,mata,xiaohu,mlxg）
                        3.查询指定位置的的人员的名字，查询索引位置为0的人员为uzi
                        4.根据名字查询该人员在场上的索引位置，代号mata的人员在场上的索引位置2
                        5.替换场上索引位置为2的人员，替换之后该人员为ming,ming把mata替换了
                        6.替换名字为looper的人员员，替换之后为letme。
                        7.假设，把场上索引位置为2的人员罚下场，没补位
                        8.按照人员在场上的位置，打印出球该成员的名字可打印分割
 
通过上面的代码发现了数组的局限性

　　数组的局限性分析：

　插入快，查找慢，删除慢，数组一旦创建后，大小就固定了，不能动态扩展数组的元素个数。如果初始化你给一个很大的数组大小，那会白白浪费内存空间，如果给小了，后面数据个数增加了又添加不进去了。

     链表：

            链表：是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。

            1.单项链表：只能从头遍历到尾巴，或者从尾巴遍历到头部，就像火车头和火车尾。

        2.双向链表：可以看做是两个单项列表，一个可以从头到尾，一个可以从尾到头。

            通过引用表示上一个节点和下一个节点的关系

举个栗子：对双向列表的增删

    

package com.alphabet.link;

public class MyLinked {
         private Node frist;  //第一个节点
        private Node last;  //最后一个节点
        private int size=0;  //节点的数量
        
        public void remove(Object obj) {
            // TODO Auto-generated method stub
            Node n=this.frist;
            for (int i = 0; i < size; i++) {
                if (!n.size.equals(obj)) {
                    if (n.next==null) {
                        return;
                    }
                    n=n.next;
                }
            }
            //删除节点
            if (n==frist) {
                this.frist=n.next;
                this.frist.prev=null;
            }else if (n==last) {
                this.last=n.prev;
                this.last.next=null;
            }else {
                n.prev.next=n.next;
                n.next.prev=n.next;
                
            }
            System.out.println("该删除的值"+n.size);//找到被删除的节点
        }
        
        public void addlast(Object obj) {//需要保存的节点对象
            // TODO Auto-generated method stub
            Node node=new Node(size);
            if (size == 0) {
                this.frist=node;
                this.last=node;
            }else {
                this.last.next=node.frist;//把之前第一个作为新增下一个的节点
                node.prev=this.last;//把新增节点作为之前第一个节点的上一个节点
                
                this.last=node;//把新增节点作为最后一个节点
                this.frist.prev=node;//把之前新增节点作为之前第一个节点的上一个
                this.frist=node;//把新增节点作为第一个节点
            }
            size++;
        }
        
        public void addfrist(Object obj) {//需要保存的节点对象
            // TODO Auto-generated method stub
            Node node=new Node(size);
            if (size == 0) {
                this.frist=node;
                this.last=node;
            }else {
                this.last.next=node;//把新增节点作为之前最后一个的下一个的节点
                node.prev=this.last;//把之前最后一个节点作为新增节点的上一个节点
                this.last=node;//把新增节点作为最后一个节点
            }
            size++;
        }
        @Override
        public String toString() {
        // TODO Auto-generated method stub
            if (size==0) {
                return "[]";
            }
            StringBuilder s=new StringBuilder(size*2+1);
            Node n=this.frist;
            s.append("[");
            for (int i = 0; i < size; i++) {
                s.append(n.size);
                if (i!=size-1) {
                    s.append(",");
                } else {
                    s.append("]");
                }
                n=n.next;//获取自己的下一个节点
            }
        return super.toString();
        }
    public class Node{
        public Node frist;
        private Node prev;//上一个节点
        private Node next;//下一个节点对象
        private Object size;//当前节点中存储的数据
        public Node(Object obj) {
            // TODO Auto-generated constructor stub
            this.size=obj;
        }
    }
    public static void main(String[] args) {
        MyLinked link=new MyLinked();
        link.addfrist("A");
        System.out.println(link);
        link.addfrist("B");
        link.addfrist("D");
        
    }
}

 

 
 

 


 
                
           
                



























以上是关于java的数组和链表的主要内容，如果未能解决你的问题，请参考以下文章

栈的数组和链表实现（Java实现）

Java 数组和链表的区别以及使用场景

数组和链表的区别

Java用数组和链表实现队列

JAVA-初步认识-常用对象API(集合框架-数组和链表)

Java集合核心内容之数组和链表，大厂越来越注重基础了，建议收藏