精华内容
下载资源
问答
  • 比如:[1,2,3] ['a','b','c']数组描述的是相同类型的若干个数据,按照一定的先后顺序排列组合而成,比如:上学时候都有班级编号,["尖子班","普通版","差班"] 他们的班级号为 0,1,2其中,每一个数据都是数组的元素,...

    7affe63f500a9dcabbc55a7ffaead18a.png
    人的生命,似洪水奔流,不遇着岛屿和暗礁,难以激起美丽的浪花。

    简介

    • 数组是相同类型数据的有序集合 比如:[1,2,3] ['a','b','c']
    • 数组描述的是相同类型的若干个数据,按照一定的先后顺序排列组合而成,比如:上学时候都有班级编号,["尖子班","普通版","差班"] 他们的班级号为 0,1,2
    • 其中,每一个数据都是数组的元素,没个数组元素都可以通过一个下标来访问它。比如:每个班级都有老师,现在按照班级顺序组合了一个老师们的集合,["猿氏凯",“诺克萨斯”,"马尔扎哈"] 猿氏凯的下标就是0、诺克萨斯的下标就是1,马尔扎哈的下标就是2

    数组的定义

    • 定义一个普通变量类型:变量的类型 变量名称 = 变量的值,例:int i = 1;
    • 与之对应,定义一个数组类型:数组类型[] 数组名称 = new 变量类型[数量],例:int[] i = new int[4];

    案例

     public static void arrayTest(){
    
       // 数组的动态赋值方式 ---------------------------------------------
       String[] strings = new String[3];
       strings[0] = "尖子班";
       strings[1] = "普通班";
       strings[2] = "差班";
       System.out.println(strings[1]); // 输出普通班
       String string = new String();
       for (int i = 0; i < strings.length; i++) {
         string += "班级:"+i+"是"+strings[i]+"/";
       }
       System.out.println(string); // 输出 班级:0是尖子班/班级:1是普通班/班级:2是差班/
       
       // 数组的静态赋值方式 ---------------------------------------------
       int[] ints = {1,2,3,4,5,6};
    
     }

    数组的特点

    • 长度是确定的,数组一旦被创建,他的大小就是不可以改变的,比如:int[] ints = new int[10] 这个ints的数组大小就是10,不可被改变
    • 元素必须是相同类型,不允许出现混合类型,不能说你定义的是int类型的数组,然后你赋值的时候给了一个String
    • 数组中的元素可以是任何数据类型,包括基本类型和引用类型
    • 数组属于引用类型,数组也可以看成是一个对象,数组中的每个元素都相当于该对象的成员变量。
    • 数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
    • 数组的下标是从0开始的,越界会报错

    总结

    • 数组是相同数据类型的有序集合
    • 数组也可以是对象,数组元素相当于对象的成员变量
    • 数组长度是在初始化时确定的,不可以改变的。不可以越界,否则会报错:ArrayIndexOutBounds

    本文作者《猿氏·凯》,如果雷同,纯属抄袭····

    展开全文
  • 对象数组 java 0913 普通数组的定义与使用 public class test2 { public static void main(String[] args) { System.out.println("定义普通数组并使用"); int[] numArray = new int[3]; System.out.println(...

    对象数组 java 0913

    普通数组的定义与使用

    public class test2 {
        public static void main(String[] args) {
            System.out.println("定义普通的数组并使用");
            int[] numArray = new int[3];
            System.out.println("数组定义好后,里面是可以存放数据的,数组就是有序的容器");
            numArray[0] = 22;
            numArray[1] = 23;
            numArray[2] = 54;
            System.out.println("数组定义完成");
            System.out.println();
            System.out.println("开始遍历数组");
            for (int i = 0; i < numArray.length; i ++) {
                System.out.println(numArray[i]);
            }
        }
    }
    
    

    效果

    定义普通的数组并使用
    数组定义好后,里面是可以存放数据的,数组就是有序的容器
    数组定义完成
    
    开始遍历数组
    22
    23
    54
    
    

    什么是对象数组

    普通的数组是存放普通数据的容器

    • String[],存放字符串数据
    • int[],存放整数数据

    对象数组是用于存放对象数据的

    如果我有很多个自定义对象需要保存

    可以考虑用对象数组进行有序存储

    例子

    public class test3 {
        public static void main(String[] args) {
            System.out.println("这里有三个学生对象,期望把他们收纳在一个数据中");
            System.out.println("数组的特点就是进行有序收纳,所以可以用数组");
            // 三个学生的实例化,分别为1号学生,2号学生,3号学生
            Student no1 = new Student();
            no1.number = 1;
            Student no2 = new Student();
            no2.number = 2;
            Student no3 = new Student();
            no3.number = 3;
    
            // 把三个学生收纳到一个数组中
            // 数组的定义,格式如下
            // 类型名[] 数组名 = new 类型名[长度];
            Student[] myStudents = new Student[4];
            System.out.println("定义了一个对象数组,可以保存四个学生对象");
            System.out.println("数组的每一个下标都可以存放一个值,下面开始存值");
            myStudents[0] = no1;
            System.out.println(" 学号为1的学生,分配在了数组的0号位");
            myStudents[1] = no2;
            System.out.println("学号为2的学生,分配在了数组的1号位");
            myStudents[3] = no3;
            System.out.println("学号为3的学生,分配在了数组的3号位");
            System.out.println("数组的2号位,没有数据");
    
            System.out.println("遍历数组");
            for (int i = 0; i < myStudents.length; i++) {
    //            System.out.println(myStudents[i]);
                // 注意,通过对象数组[下标],取出来的值,就是一个学生对象
                // 即 myStudents[下标]的值是一个学生对象
                // 所以,我们可以通过  学生对象.属性,可以操做学生对象的属性
                if (myStudents[i] != null) {
                    System.out.println("学生学号为"+myStudents[i].number);
                }
    
            }
    
        }
    }
    
    

    结果

    "C:\Program Files\Java\jdk1.7.0_17\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA Educational Edition 2020.2\lib\idea_rt.jar=5241:D:\Program Files\JetBrains\IntelliJ IDEA Educational Edition 2020.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.7.0_17\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\jce.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\jfxrt.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\resources.jar;C:\Program Files\Java\jdk1.7.0_17\jre\lib\rt.jar;E:\code2020\小功能演练0913\out\production\小功能演练0913" test3
    这里有三个学生对象,期望把他们收纳在一个数据中
    数组的特点就是进行有序收纳,所以可以用数组
    定义了一个对象数组,可以保存四个学生对象
    数组的每一个下标都可以存放一个值,下面开始存值
     学号为1的学生,分配在了数组的0号位
    学号为2的学生,分配在了数组的1号位
    学号为3的学生,分配在了数组的3号位
    数组的2号位,没有数据
    遍历数组
    学生学号为1
    学生学号为2
    学生学号为3
    
    Process finished with exit code 0
    
    

    视频

    https://www.ixigua.com/6871870761636725256?logTag=8Ne_wehmtb6GcNWDF7B-S

    展开全文
  • 普通int:public class Array {//成员变量private int[] data;private int size;//构造函数,传入数组的容量capacity构造Arraypublic Array(int capacity){data=new int[capacity];size=0;}//无参数构造函数,默认数...

    普通int:

    public class Array {

    //成员变量

    private int[] data;

    private int size;

    //构造函数,传入数组的容量capacity构造Array

    public Array(int capacity){

    data=new int[capacity];

    size=0;

    }

    //无参数构造函数,默认数组的容量capacity=10

    public Array(){

    this(10);

    }

    //获取数组中元素的个数

    public int getSize(){

    return size;

    }

    //获取数组的容量

    public int getCapacity(){

    return data.length;

    }

    //返回数组是否为空

    public boolean isEmpty(){

    return size==0;

    }

    //向所有元素后添加一个新元素

    public void addLast(int e){

    add(size, e);

    }

    //在所有元素前面添加一个新元素

    public void addFirst(int e){

    add(0, e);

    }

    //获取index索引的位置的元素

    int get(int index){

    if(index<0||index>=size)

    throw new IllegalArgumentException("Get failed.Index is illegal.");

    return data[index];

    }

    //修改index索引位置的元素为e

    void set(int index,int e){

    if(index<0||index>=size)

    throw new IllegalArgumentException("Get failed.Index is illegal.");

    data[index]=e;

    }

    //查找数组中是否有元素e

    public boolean contains(int e){

    for(int i=0;i

    if(data[i]==e){

    return true;

    }

    }

    return false;

    }

    //查找数组中元素e所在的索引,如果不存在元素e,则返回-1

    public int find(int e){

    for(int i=0;i

    if(data[i]==e){

    return i;

    }

    }

    return -1;

    }

    //从数组中删除index位置的元素,返回删除的元素

    public int remove(int index){

    if(index<0||index>=size)

    throw new IllegalArgumentException("Remove failed.Index is illegal.");

    int ret=data[index];

    for(int i=index+1;i

    data[i-1]=data[i];

    size--;

    return ret;

    }

    //从数组中删除第一个元素,返回删除的元素

    public int removeFirst(){

    return remove(0);

    }

    //从数组中删除最后一个元素,返回删除的元素

    public int removeLast(){

    return remove(size-1);

    }

    //从数组中删除元素e

    public void removeElement(int e){

    int index=find(e);

    if(index!=-1)

    remove(index);

    }

    //在第index个位置插入一个新元素e

    public void add(int index,int e){

    if(size==data.length)

    throw new IllegalArgumentException("Add failed.Array is full.");

    if(index<0||index>size)

    throw new IllegalArgumentException("Add failed.Require index>=0 and index<=size.");

    for(int i=size-1;i>=index ;i--)

    data[i+1]=data[i];

    data[index]=e;

    size++;

    }

    @Override

    public String toString(){

    StringBuilder res=new StringBuilder();

    res.append(String.format("Array:size=%d,capacity=%d\n", size,data.length));

    res.append(‘[‘);

    for(int i=0;i

    res.append(data[i]);

    if(i!=size-1)//判断是否是最后一个元素

    res.append(",");

    }

    res.append(‘]‘);

    return res.toString();

    }

    }

    泛型:

    public class Array {

    //成员变量

    private E[] data;

    private int size;

    //构造函数,传入数组的容量capacity构造Array

    public Array(int capacity){

    data=(E[])new Object[capacity];

    size=0;

    }

    //无参数构造函数,默认数组的容量capacity=10

    public Array(){

    this(10);

    }

    //获取数组中元素的个数

    public int getSize(){

    return size;

    }

    //获取数组的容量

    public int getCapacity(){

    return data.length;

    }

    //返回数组是否为空

    public boolean isEmpty(){

    return size==0;

    }

    //向所有元素后添加一个新元素

    public void addLast(E e){

    add(size, e);

    }

    //在所有元素前面添加一个新元素

    public void addFirst(E e){

    add(0, e);

    }

    //获取index索引的位置的元素

    public E get(int index){

    if(index<0||index>=size)

    throw new IllegalArgumentException("Get failed.Index is illegal.");

    return data[index];

    }

    //修改index索引位置的元素为e

    public void set(int index,E e){

    if(index<0||index>=size)

    throw new IllegalArgumentException("Get failed.Index is illegal.");

    data[index]=e;

    }

    //查找数组中是否有元素e

    public boolean contains(E e){

    for(int i=0;i

    if(data[i].equals(e){

    return true;

    }

    }

    return false;

    }

    //查找数组中元素e所在的索引,如果不存在元素e,则返回-1

    public int find(E e){

    for(int i=0;i

    if(data[i].equals(e)){

    return i;

    }

    }

    return -1;

    }

    //从数组中删除index位置的元素,返回删除的元素

    public E remove(int index){

    if(index<0||index>=size)

    throw new IllegalArgumentException("Remove failed.Index is illegal.");

    E ret=data[index];

    for(int i=index+1;i

    data[i-1]=data[i];

    size--;

    data[size]=null;//loitering objects!=memory leak

    return ret;

    }

    //从数组中删除第一个元素,返回删除的元素

    public E removeFirst(){

    return remove(0);

    }

    //从数组中删除最后一个元素,返回删除的元素

    public E removeLast(){

    return remove(size-1);

    }

    //从数组中删除元素e

    public void removeElement(E e){

    int index=find(e);

    if(index!=-1)

    remove(index);

    }

    //在第index个位置插入一个新元素e

    public void add(int index,E e){

    if(size==data.length)

    throw new IllegalArgumentException("Add failed.Array is full.");

    if(index<0||index>size)

    throw new IllegalArgumentException("Add failed.Require index>=0 and index<=size.");

    for(int i=size-1;i>=index ;i--)

    data[i+1]=data[i];

    data[index]=e;

    size++;

    }

    @Override

    public String toString(){

    StringBuilder res=new StringBuilder();

    res.append(String.format("Array:size=%d,capacity=%d\n", size,data.length));

    res.append(‘[‘);

    for(int i=0;i

    res.append(data[i]);

    if(i!=size-1)//判断是否是最后一个元素

    res.append(",");

    }

    res.append(‘]‘);

    return res.toString();

    }

    }

    测试:

    public class Student {

    private String name;

    private int score;

    public Student(String studentName,int studentScore){

    name=studentName;

    score=studentScore;

    }

    public String toString(){

    return String.format("Student(name:%s,score:%d)", name,score);

    }

    public static void main(String[] args){

    Array arr=new Array<>();

    arr.addLast(new Student("Alice", 100));

    arr.addLast(new Student("Bob", 66));

    arr.addLast(new Student("CharLie", 88));

    System.out.println(arr);

    }

    }

    展开全文
  • 数据结构–稀疏数组Java实现) 博客说明 文章所涉及的资料来自互联网整理和个人总结,意在于个人学习和经验汇总,如有什么地方侵权,请联系本人删除,谢谢! 简介 稀疏数组普通数组的压缩,普通数组指的是无效...
  • 1、假溢出​系统作为队列用的存储区还没有满,但队列却发生了溢出,我们把这种现象称为"假溢出"。...​将普通队列想象成逻辑上的首位相连的圆环,把这个叫循环队列,在循环队列中,当队列为空时,有f...

    1、假溢出

    ​系统作为队列用的存储区还没有满,但队列却发生了溢出,我们把这种现象称为"假溢出"。

    eee7b2cf58c277ad59ecfca99fe1cdca.png

    因为队列遵从从队尾存入数据,从队头取数据,所以红框部分的空间就不能继续存入新的数据,此时队列有多余的空间,却不能存入值,这种现象就叫做假溢出现象

    2、循环队列介绍

    ​充分利用了空间,解决“假溢出”的问题

    【循环队列思想】

    ​将普通队列想象成逻辑上的首位相连的圆环,把这个叫循环队列,在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件是front=rear,而队列判满的条件是front=(rear+1)%MaxSize。

    2e84de94ca334f22df72abbfb48c52a2.png

    【为什么要空一个存储单元】

    ​我有想过这个问题,rear一直是空的,我为什么不能在里面存值,而我队列判满的条件也是front=(rear+1)%MaxSize,似乎很合情合理,那么我们把目光转到开头,当我存入第一个数字的时候,队尾肯定是要加一的,如果我front,rear的初始值像普通队列那样都为-1,才不会自相矛盾,但是这是个循环队列,当第二轮的时候,这个就不管用了,所以一定要空一个存储单元。

    3、Java代码实现

    1、确定有哪些元素

    头尾标志:rear,front,并且初值都为0

    最大长度

    定义一个数组,这次我决定用泛型(泛型数组,这部分知识很有意思,建议尝试)

    【代码实现】

    public class CircleArrayQueue {

    //最大长度

    private int maxSize;

    //头尾标志

    private int rear;

    private int front;

    T[] array;

    public CircleArrayQueue(int maxSize,Class type){

    init(maxSize,type);

    }

    //初始化

    private void init(int maxSize,Class type){

    //个人觉得这个是个黑盒实现,使用的人传入maxSize大小,你不应该只给他创造maxSize-1的大小

    this.maxSize = maxSize+1;

    rear = 0;

    front = 0;

    array = (T[]) Array.newInstance(type,this.maxSize);

    }

    //判断队满

    public boolean isFull(){

    //rear和front的变化一定要记得是个循环,不然很容易搞错,我就搞错好多次

    return (rear+1)%maxSize == front;

    }

    //判断队空

    public boolean isEnpty(){

    return rear == front;

    }

    //插入

    public void add(T t){

    if(isFull()){

    throw new RuntimeException("队列已满");

    }

    array[rear] = t;

    rear = (rear+1)%maxSize;

    }

    //取元素

    public T get(){

    if(isEnpty()){

    throw new RuntimeException("队列为空");

    }

    T t = array[front];

    front = (front+1)%maxSize;

    return t;

    }

    //获得长度

    public int size(){

    return (rear+maxSize-front)%maxSize;

    }

    //打印所有数据

    public void showData(){

    int length = this.size();

    int head = front;

    for (int i = 0; i < length; i++) {

    //先执行array[head],再自加

    System.out.println(array[head]);

    head = (head+1)%maxSize;

    }

    }

    }

    个人写的代码水平比较低,仅供参考。

    展开全文
  • 数据结构–稀疏数组Java实现) 博客说明 文章所涉及的资料来自互联网整理和个人总结,意在于个人学习和经验汇总,如有什么地方侵权,请联系本人删除,谢谢! 简介 稀疏数组普通数组的压缩,普通数组指的是无效...
  • 一种是普通的,一种是带有数组形式的;普通形式的:服务器端返回的json数据格式如下:{"userbean":{"Uid":"100196","Showname":"\u75af\u72c2\u7684\u7334\u5b50","Avtar":null,"State":1}}分析代码如下:// TODO ...
  • JAVA读取本地txt文件,并将每行数据存入数组的方法:/*** 读取本地普通文件,将其转化为一个字符串数组* @return*/public ArrayList getTxt(String filepath){try{String temp = null;File f = new File(filepath);...
  • JAVA读取本地txt文件,并将每行数据存入数组的方法:/*** 读取本地普通文件,将其转化为一个字符串数组* @return*/public ArrayList getTxt(String filepath){try{String temp = null;File f = new File(filepath);...
  • JAVA读取本地txt文件,并将每行数据存入数组的方法:/*** 读取本地普通文件,将其转化为一个字符串数组* @return*/public ArrayList getTxt(String filepath){try{String temp = null;File f = new File(filepath);...
  • 稀疏数组简介: 所谓稀疏数组就是当数组中大部分的内容值都未被使用(或都为零),在数组中仅有少部分的空间使用。因此造成内存空间的浪费,为了节省内存空间,并且不影响数组中原有的内容值,我们可以使用稀疏数组...
  • 我必须处理大量的小整数,最大为1700万(值始终在0-255之间),并将它们存储在某种类型的数组上,我目前使用的是普通的int数组,并且性能不是最好的( 符合预期)。每次执行时,程序都会访问该数组的所有值约260次,因此...
  • 可变长参数之前在Java中,我们定义一个方法的参数的个数都是定义死的,但有时候我们希望它能够接收多个参数,这时候就需要用到我们的可变长参数了,那么它怎么用呢?我们来看看下面的例子:从上面其实我们就可以知道...
  • #java实现稀疏数组普通数组的转换 /** * 稀疏数组 */ public class SparseArrayTest { public static void main(String[] args) { // 从普通数组转到稀疏数组 //1.先建立一个普通数组,遍历得到有效数据。 0...
  • 程序如下:importjava.util.Arrays;//importjava.lang.Comparable;classPersonimplementsCloneable{privateStringname;privateintage;publicPerson(Stringname,intage){this.name=nam...程序如下:import java.util....
  • 展开全部写了个例子,请仔细查看代码,具体过程需要你自己对照java API 再研究,先定义了一个普通32313133353236313431303231363533e4b893e5b19e31333337393466的学生类,如下:publicclassStudent{privateintid;...
  • 使用此方法,您可以获取JSONArray对象的元素,并使用它们填充数组。示例importjava.util.Arrays;importorg.json.JSONArray;publicclassJsonToArray{publicstaticvoidmain(Stringargs[])throwsException{St...
  • 数据结构之稀疏数组普通数组的转换(Java实现) package com.lilulu.SparseArray; public class SparseArray { public static void main(String[] args) { /** * 创建一个原始的11*11的二维数组 * 0表示没有...
  • Java基础学习可变参数在方法声明中,在指定参数类型后加一个省略号(...)。一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通参数都必须在它之前声明。public class printMax {public static ...
  • 数组实现队列的基本操作 package ArrayQueue; import java.util.ArrayList; /** * @program: 队列相关操作 * @description: 用于模拟队列操作的类 * @author: Zhou Jian * @create: 2020-07-08 18:45 */...
  • 原标题:Java数组普通对象的引用变量有什么区别1、数组普通对象的引用变量有什么区别了解什么是数组看这里:java中的数组是什么对于Java数组来说,只有类型兼容(即属于同一数据类型体系且遵守优先级由低到高...
  • Java基础学习可变参数在方法声明中,在指定参数类型后加一个省略号(...)。一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通参数都必须在它之前声明。public class printMax {public static ...
  • 有别于普通的“类的实例”对象,java数组不是类,所以也就没有对应的class文件,数组类型是由jvm从元素类型合成出来的;在jvm中获取数组的长度是用arraylength这个专门的字节码指令的; 在数组的对象头里有一个_...
  • 今天是刘小爱自学Java的第110天。感谢你的观看,谢谢你。话不多说,开始今天的学习:事先说明:关于今天的搜索功能实现。并没有使用到倒排索引这样的主流搜索技术,就一个普通的模糊查询。在此之前,先学一个小的...
  • 普通数组的元素个数是固定的,当数组满了之后要怎么办?数组要有多大才合适,有时提前并不知道。所以希望能够在运行时具有改变数组大小的能力。动态数组就可以在任何时候改变大小。动态数组是指在声明时没有确定数组...
  • 是的,就像在普通SQL中一样,您可以指定要选择的属性类型:SELECT i.firstProperty, i.secondProperty FROM ObjectName i WHERE i.id=10执行此查询将返回Object []的列表,其中每个数组都包含一个对象的选定属性。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,235
精华内容 894
关键字:

数组普通java

java 订阅