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");

}

}

原文地址:https://www.cnblogs.com/lw687a/p/9508756.html

时间: 2024-10-12 09:15:34

java的数组和链表的相关文章

Java基础知识强化之集合框架笔记21:数据结构之 数组 和 链表

1. 数组 2. 链表

数据结构Java实现04----循环链表、仿真链表

数据结构Java实现04----循环链表.仿真链表 单向循环链表 双向循环链表 仿真链表 一.单向循环链表: 1.概念: 单向循环链表是单链表的另一种形式,其结构特点是链表中最后一个结点的指针不再是结束标记,而是指向整个链表的第一个结点,从而使单链表形成一个环. 和单链表相比,循环单链表的长处是从链尾到链头比较方便.当要处理的数据元素序列具有环型结构特点时,适合于采用循环单链表. 和单链表相同,循环单链表也有带头结点结构和不带头结点结构两种,带头结点的循环单链表实现插入和删除操作时,算法实现较为

数据结构Java实现03----单向链表的插入和删除

数据结构Java实现03----单向链表的插入和删除 文本主要内容: 链表结构 单链表代码实现 单链表的效率分析 一.链表结构:            概念: 链式存储结构是基于指针实现的.我们把一个数据元素和一个指针称为结点.   数据域:存数数据元素信息的域. 指针域:存储直接后继位置的域. 链式存储结构是用指针把相互直接关联的结点(即直接前驱结点或直接后继结点)链接起来.链式存储结构的线性表称为链表. 链表类型: 根据链表的构造方式的不同可以分为: 单向链表 单向循环链表 双向循环链表 二

数组与链表的区别?

数组与链表的区别? Java 数组 链表 (附件: markdownFile.md) 来自为知笔记(Wiz) 附件列表

java对象数组的概述和使用

1 public class Student 2 { 3 // 成员变量 4 private String name; 5 private int age; 6 7 // 构造方法 8 public Student() 9 { 10 super(); 11 } 12 13 public Student(String name, int age) 14 { 15 super(); 16 this.name = name; 17 this.age = age; 18 } 19 20 // 成员方法

JAVA实现数组队列,循环数组队列,链式队列

/** * 文件名:QueueText.java * 时间:2014年10月22日下午9:05:13 * 作者:修维康 */ package chapter3; /** * 类名:ArrayQueue * 说明:队列的数组实现 */ class ArrayQueue<AnyType>{ private static final int DEFAULT_CAPACITY = 10; private int front;//队头 private int rear;//队尾 private int

数组、链表、Hash(转)

在程序中,存放指定的数据最常用的数据结构有两种:数组和链表. 数组和链表的区别: 1.数组是将元素在内存中连续存放. 链表中的元素在内存中不是顺序存储的,而是通过存在元素中的指针联系到一起. 2.数组必须事先定义固定的长度,不能适应数据动态地增减的情况.当数据增加时,可能超出原先定义的元素个数:当数据减少时,造成内存浪费. 链表动态地进行存储分配,可以适应数据动态地增减的情况. 3.(静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小. 链表从堆中分配空间, 自由度大但是申请管理比较麻

Java描述数据结构之链表的增删改查

链表是一种常见的基础数据结构,它是一种线性表,但在内存中它并不是顺序存储的,它是以链式进行存储的,每一个节点里存放的是下一个节点的"指针".在Java中的数据分为引用数据类型和基础数据类型,在Java中不存在指针的概念,但是对于链表而言的指针,指的就是引用数据类型的地址. 链表和数组都是线性的数据结构,对于数组而言其长度是固定的,由于在内存中其是连续的,因此更适合做查找与遍历,而链表在内存中是并不是顺序存储的,但是由于其是通过"指针"构成的,因此在插入.删除时比较数

Java中数组在内存中的图解

Java中的数组在内存中的图解,其实对于数组,还是比较熟悉的,平时用的也是很多的,在看数据结构与算法的极客时间专栏,最常用的10个数据结构:数组.链表.栈.队列.散列表.二叉树.堆.跳表.图.Trie树,其中数组是最基础,也是学起来最简单的一种数据结构,数组是一种线性表数据结构.它用一组连续的内存空间,来存储一组具有相同类型的数据. 以下三张图片都是极客时间专栏中的,嘿嘿嘿!!! 数组是计算机分配的一组连续的内存空间 接下来,具体到Java语言,来说说数组吧:(这个是传智播客上的讲解图,这么好的