精华内容
下载资源
问答
  • 数组是基本的数据结构 , 在 Java 语言中也比较常用 , 但是 Java提供的Array 数组, 有诸多不便, 并且也是静态数组, 刚好最近研究了一下数据结构, 将Array 封装了一下 , 代码如下 /** * Created by Lucas Ma Date:...

    >>点击领取阿里云优惠券<<

    数组是基本的数据结构 , 在 Java 语言中也比较常用 , 但是 Java提供的Array 数组, 有诸多不便, 并且也是静态数组, 刚好最近研究了一下数据结构, 将Array 封装了一下 , 代码如下

    /**
     * Created by Lucas Ma Date:2018/4/24
     * Java 数组的二次封装
     */
    public class Array<E> {
    
        private E[] data;
        private int size;
    
        /**
         * 构造函数,传入数组的容量 capacity 构造 Array
         *
         * @param capacity
         */
        public Array(int capacity) {
            data = (E[]) new Object[capacity];
            size = 0;
        }
    
        /**
         * 无参构造函数, 默认是 10
         */
        public Array() {
            this(10);
        }
    
        /**
         * 获取数组中元素的个数
         *
         * @return
         */
        public int getSize() {
            return size;
        }
    
        /**
         * 获取数组的容量
         *
         * @return
         */
        public int getCapacity() {
            return data.length;
        }
    
        /**
         * 返回数组是否为空
         *
         * @return
         */
        public boolean isEmpty() {
            return size == 0;
        }
    
        /**
         * 向所有元素后添加一个新的元素
         *
         * @param e
         */
        public void addLast(E e) {
            add(size, e);
        }
    
        /**
         * 在所有元素之前添加一个新元素
         *
         * @param e
         */
        public void addFirst(E e) {
            add(0, e);
        }
    
        /**
         * 在第 index 位置插入一个元素
         *
         * @param index
         * @param e
         */
        public void add(int index, E e) {
    
            if (index < 0 || index > size) {
                throw new IllegalArgumentException("Add failed , Require index >=0 and index <=size.");
            }
            if (size == data.length) {
                resize(2 * data.length);
            }
            for (int i = size - 1; i >= index; i--) {
                data[i + 1] = data[i];
            }
    
            data[index] = e;
            size++;
        }
    
        /**
         * 获取index 位置的索引
         *
         * @param index
         * @return
         */
        public E get(int index) {
            if (index < 0 || index > size) {
                throw new IllegalArgumentException("Get failed , index is illegal");
            }
            return data[index];
        }
    
        /**
         * 修改index 位置的元素
         *
         * @param index
         * @param 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
         *
         * @param e
         * @return
         */
        public boolean contains(E e) {
            for (int i = 0; i < size; i++) {
                if (data[i].equals(e)) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 查找数组e所在的索引, 如果不存在 返回 -1
         *
         * @param e
         * @return
         */
        public int find(E e) {
            for (int i = 0; i < size; i++) {
                if (data[i].equals(e)) {
                    return i;
                }
            }
            return -1;
        }
    
        /**
         * 从数组中删除 index 位置的元素, 返回删除的元素
         *
         * @param index
         * @return
         */
        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 < size; i++) {
                data[i - 1] = data[i];
            }
            size--;
            if (size == data.length / 2) {
                resize(data.length / 2);
            }
            return ret;
        }
    
        /**
         * 从数组中删除第一个元素 , 返回删除的元素
         *
         * @return
         */
        public E removeFirst() {
            return remove(0);
        }
    
        /**
         * 从数组中删除最后一个元素, 返回删除的元素
         *
         * @return
         */
        public E removeLast() {
            return remove(size - 1);
        }
    
        /**
         * 从数组中删除元素 e
         *
         * @param e
         */
        public void removeElement(E e) {
            int index = find(e);
            if (index != -1) {
                remove(index);
            }
        }
    
        /**
         * 从数组中删除所有的 e
         *
         * @param e
         */
        public void removeAllElement(E e) {
            for (int i = 0; i < size; i++) {
                if (data[i].equals(e)) {
                    removeElement(data[i]);
                }
            }
        }
    
        /**
         * 从数组中删除元素 e 并返回删除结果
         *
         * @param e
         * @return
         */
        public boolean removed(E e) {
            int index = find(e);
            if (index != -1) {
                if (remove(index).equals(e)) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
    
    
        @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 < size; i++) {
                res.append(data[i]);
                if (i != size - 1) {
                    res.append(", ");
                }
            }
            res.append(']');
            return res.toString();
        }
    
        /**
         * 扩容或者缩容数组
         *
         * @param newCapacity
         */
        private void resize(int newCapacity) {
            E[] newData = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            data = newData;
        }
    }
    
    展开全文
  • 去年用java开发安卓APP的时候,感觉其中的ArrayList的API比较好用的。 就想能否用js封装一个类似的类,更好的进行数组操作呢。...simple array list implementation in javascript like java const ArrayLi...

    初衷

    之前java开发安卓APP的时候,感觉其中的ArrayList的API比较好用的。

    就想能否用js封装一个类似的类,更好的进行数组操作呢。

    因为前端经常后端返回的列表数组进行增删改查乱序,排序等操作,如果能有一个封装的类来代替

    预期是相对原生的API的操作还是能提高点效率的。 例如:左滑操作显示删除某个元素 原生:list.splice(index,1)再此之前还要获取到index.有时候index不一定准确。而用了该ArrayList后可以:mList.remove(index)或者mList.remove(item)移除整个对象。
    排序/打乱顺序:原生:list.sort(…)其实排列demo级别如纯数字数组[1,2,3,7,23,6]这样的还行。但是如果是对数组对象进行排序,如果有超过10项,速度就很明显慢下来;所以ins-array-list针对此进行了优化,内部使用希尔排序来做排序和乱序,经测试执行速度很快:mList.sort(…);mList.shuffle();

    简单介绍

    主要涉及以下API,用到方法重载,数组越界等边界报错处理,具体看README

    npm package:ins-array-list

    simple array list implementation in javascript like java

    $ npm install ins-array-list --save
    
     const ArrayList=require('ins-array-list')
     const testList = [
          {
            id: 1,
            name: 'Alicy',
            gender: 2
          },
          {
            id: 2,
            name: 'Anna',
            gender: 2
          },
          {
            id: 3,
            name: 'Tom',
            gender: 1
          }
        ]
       let mList = new ArrayList(testList, 'id')//id为对象的主键,任何一个API操作涉及对象的重复,添加或删除等操作等确认动作都会用到这个id.
       //例如继续添加id=1的数据会报错
       //以下用add简单介绍下api
       mList.add({id:1,name:'Steve',gender:1})//=>throw error mList.size==3
       mList.add({id:4,name:'Steve',gender:1})//=>true mList.size()==4
       mList.add(1,{id:5,name:'Miya,gender:2}),//=>true 在index=1添加id=5的对象
       //更多api 伪代码
       mList.addAll(subList)
       mList.addAll(index,subList)
       mList.remove(index)
       mList.remove(item)
       mList.removeIf(predicator)
       mList.subList(formIndex,toEndIndex)
       mList.sort()
       mList.shuffle()
       mList.iterate(iterator)
       mList.contains(item)
       mList.isEmpty()
       mList.clear()
       mList.get(index)
       mList.set(index,item)
       mList.size()
       //特别说明
       mList.source属性可能获取到最新的对象数组
      
    

    具体使用可以看npm
    或者Github里的README enjoy!

    展开全文
  • Java封装封装性在Java当中的体现:1.方法就是一种封装2.关键字private也是一种封装封装就是将一些细节信息.隐藏起来,对于外界不可见。public class Method {public static void main(String[] args) {int[] array =...

    Java封装

    封装性在Java当中的体现:

    1.方法就是一种封装

    2.关键字private也是一种封装

    封装就是将一些细节信息.隐藏起来,对于外界不可见。

    public class Method {

    public static void main(String[] args) {

    int[] array ={1,2,3,4,5,100};

    int max = getMax(array);

    System.out.println("最大值:"+max);

    }

    //给我一个数组,我换给你一个最大值

    //以下为定义一个方法

    public static int getMax(int[] array){

    int max = array[0];

    for (int i = 1; i

    if(array[i]>max){

    max = array[i];

    }

    }

    return max;

    }

    }

    private关键字的作用及使用

    其目的是可以提高代码的安全性。目前就这么理解

    问题描述:定义Person的年龄时,无法阻止不合理的数值被设置进来。

    解决方案:用private关键字将需要保护的成员变量进行修饰。

    一旦使用了private进行修饰,那么本类当中仍然可以随意访问。

    但是!超出了本类范围之外就不能再直接访问了。

    间接访问private成员变量,就是定义一对Getter/Setter方法

    必须叫setXxx或者是getXxx命名规则。

    对于Getter来说,不能有参数,返回值类型和成员变量对应;

    对于setter来说,不能有返回值,参数类型和成员变量对应。

    我们先来定义一个Person类

    package Day1128;

    public class Person {

    String name;//姓名

    private int age;//年龄

    public void show(){

    System.out.println("我是:"+ name +",年龄:"+ age);

    }

    //这个成员方法,专门用于向age设置数据

    public void setAge(int num) {

    if(num < 100 && num >= 9){ //如果条件合理

    //别忘了,&&是并且的意思同时满足条件,多多记吧!

    age = num;

    } else {

    System.out.println("数据错误!!!");

    }

    }

    //这个成员方法,专门用于获取age的数据

    public int getAge(){

    return age;

    }

    }

    我们再来创建一个对象

    package Day1128;

    public class D3Person {

    public static void main(String[] args) {

    Person person = new Person();

    person.show();

    person.name ="康康";

    // person.age =-20;//直接访问private内容,是错误的写法!

    //要间接访问哦!

    // person.setAge(-20);//因为在类中设置了,所以显示会为0

    person.setAge(20);

    person.show();

    }

    }

    为了怕忘记,我再来发发图看看

    c0e31ad8af877cfe648d1778418bdc5b.png

    最后一关,让我们来做做练习吧

    和上面一样,先定义一个类

    对于基本类型当中的booLean值,Getter方法一定要写成isXxx的形式,而setXxx规则不变。

    get拿进来,set放进去,记住就好了

    package Day1128;

    public class Student { //定义一个student类

    private String name; //姓名

    private int age; //年龄

    private boolean male; //是不是帅哥

    //要注意了,这个set不要写错了,我有时会打错字,这就要用心了!!

    public void setMale (boolean b){

    male = b;

    }

    public boolean isMale(){

    return male;

    }

    public void setName(String str){

    name = str;

    }

    public String getName() {

    return name;

    }

    public void setAge(int num){

    age = num;

    }

    public int getAge(){

    return age;

    }

    }

    然后再创建一个对象来执行

    package Day1128;

    public class D3Person {

    public static void main(String[] args) {

    Person person = new Person();

    person.show();

    person.name ="康康";

    // person.age =-20;//直接访问private内容,是错误的写法!

    //要间接访问哦!

    // person.setAge(-20);//因为在类中设置了,所以显示会为0

    person.setAge(20);

    person.show();

    }

    }

    本文同步分享在 博客"康贤"(CSDN)。

    如有侵权,请联系 support@oschina.cn 删除。

    本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。

    展开全文
  • import java.util.Random; import java.util.Scanner; public class ArrayDaemon{ public static void main(String[] args){ Random r = new Random(); int[] numbers =new int[10]; int len = number
    //猜数游戏
    import java.util.Random;
    import java.util.Scanner;
    public class ArrayDaemon{
    	public static void main(String[] args){
    		Random r = new Random();
    		int[] numbers =new int[10];
    		int len = numbers.length;
    		for(int i=0;i<len;i++){
    			numbers[i] = r.nextInt(20);
    			System.out.print(numbers[i]+"/");
    		}
    		
    		
    		System.out.println("  请输入一个小于20的整数:");
    		Scanner in = new Scanner(System.in);
    		int userNum = in.nextInt();
    		System.out.println("你输入的数字是:"+userNum);
    		
    		boolean flag = false;
    		
    		for(int i=0;i<len;i++){
    			if(userNum==numbers[i]){
    				//System.out.println("正确");
    				flag = true;
    				break;
    			}
    		}
    		
    		System.out.println(flag);
    		if(flag==true){
    			System.out.println("正确");
    		}else{
    			System.out.println("错误");
    		}
    	}
    }




    //数组的3种写法
    public class ArrayTest{
    	public static void main(String[] args){
    		//1.
    		int[] x;
    		x = new int[3];
    		x[0] = 10;
    		x[1] = 20;
    		x[2] = 30;
    		
    		int len = x.length;
    		System.out.println(len);
    		
    		//2.
    		int[] xx = new int[3];
    		
    		//3.
    		int[] xxx = new int[]{11,12,13};
    		
    		System.out.println(xxx[0]);
    		System.out.println(xxx[1]);
    		System.out.println(xxx[2]);
    	}
    }


    展开全文
  • ArrayList内部封装了一个Object类型的数组,从一般的意义来说,它和数组没有本质的差别,甚至于ArrayList的许多方法,如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。...
  • 软件介绍J2V8 是 V8 引擎的 Java 封装版本,注重性能和紧密集成。示例代码:V8v8=V8.createV8Runtime();V8Arrayresult=v8.executeArrayScript("varbuffer=newArrayBuffer(256);\n"+"vari32=newInt32Array(buffer);\n...
  • J2V8 是 V8 引擎的 Java 封装版本,注重性能和紧密集成。示例代码:V8v8=V8.createV8Runtime();V8Arrayresult=v8.executeArrayScript("varbuffer=newArrayBuffer(256);\n"+"vari32=newInt32Array(buffer);\n"+"i32[0...
  • 数组封装类1、基础数组语法数组声明,支持:dataType[] arrayRefVar或dataType arrayRefVar[]两种方式。推荐采用dataType[] arrayRefVar方式。创建数组:dataType[] arrayRefVar = new dataType[arraySize]或...
  • Java - Array Initialization

    千次阅读 2008-06-13 11:00:00
    数组:相同类型的、用一个标识符名称封装到一起的,一个对象序列or基本类型数据序列。数组定义方式:int[] a1; 编译器不允许指定上述代码中数组的大小。这就又把我们带回到有关“引用”的问题上。现在拥有的只是对数...
  • nextprereloadfunction eyunTree(Tname){if(typeof(Tname) != "string" || Tname == "")throw(new Error(-1, '创建类实例的时候请把类实例的引用变量名传递进来!...this.nodes=new Array();this.header="\r\n";th...
  • packageorg.liufeng.course....importjava.lang.reflect.Array;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importorg.apache.log4j.Logger;importorg.apache.log4j.PropertyConfigurator;...
  • J2V8 是 V8 引擎的 Java 封装版本,注重性能和紧密集成。示例代码:V8 v8 = V8.createV8Runtime(); V8Array result = v8.executeArrayScript("var buffer = new ArrayBuffer(256);\n"  "var i32 = ...
  • J2V8 是 V8 引擎的 Java 封装版本,注重性能和紧密集成。示例代码:V8v8=V8.createV8Runtime();V8Arrayresult=v8.executeArrayScript("varbuffer=newArrayBuffer(256);\n"+"vari32=newInt32Array(buffer);\n"+"i32[0...
  • Java封装一个自己的数组类(可以自动扩容) 封装的数组类class Array<E> /** * @author yinglongwu */ //封装一个自己的数组 //泛型<E>,表明可以存放E类型的数据,至于E是什么,可以自己定义 //Array...
  • package com.tms; import ... ... public class tojson { public static void main(String[] args) { JSONArray jsonArray = new JSONArray();... String [] array={"斯","人","若","彩","虹
  • Array.java

    2019-09-17 21:34:02
    模拟数组的底层实现 ,对数组的二次封装
  • package ...import java.io.Serializable;import java.lang.reflect.Array;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java...
  • 'use strict';//启用严格模式var oap={},obj_type={},core_toString=obj_type.toString,hasOwn = obj_type....var type_arr = "Boolean Number String Function Array Date RegExp Object Error".split(" ");...
  • //import java.util.*;public class Test {private int array[];private int nElements;public Test(int max){array = new int[max];nElements = 0;}public boolean insert(int value){if(nElements &...
  • Array动态数组 文章目录1、Array概述2、Array数组实现思路2.1、增2.2、删除元素2.3、改变元素2.4、查找元素3、时间复杂度分析4、解决时间复杂度震荡的...底层实现仍是数组,只是将数组进行封装,可以实现自...
  • Java封装 封装性在Java当中的体现: 1.方法就是一种封装 2.关键字private也是一种封装 封装就是将一些细节信息.隐藏起来,对于外界不可见。 public class Method { public static void main(String[] args) { int...
  • 自己封装的Utils类,来自google.gava / ...import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; import org.apache.com...
  • Java -- 封装

    2019-11-30 14:06:37
    封装性在Java中的体现: 1.方法就是一种封装 2.关键字private也是一种封装 public class mainjava { public static void main(String[] args) { int[] array = {5,20,25,20,100}; i...
  • Java文件操作类封装

    千次阅读 2013-11-11 14:36:30
    java文件操作类,简单封装封装了复制,剪切,删除目录,压缩解压zip,等常用功能 package com.wiker; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io....
  • //1.封装集合 List list = new ArrayList(); list.add( "first" ); list.add( "second" ); JSONArray jsonArray1 = JSONArray.fromObject( list ); System.out.println("集合:"+jsonArray1);...int[] Array
  • 封装性在Java当中的体现: 1.方法就是一种封装 2.关键字private也是一种封装 封装就是将一些细节信息隐藏起来,对于外界不可见 public class Method { public static void main(String[] args) { int[] array = {...
  • 1 面向对象简述将 {1,3,45,56,78,90}转化为[1,3,45,56,78,90]1-2 方法1:面向过程代码块public class test {public static void main(string[] args) {int[] array = {1,3,45,56,78,90};// 打印成[1,3,45,56,78,90]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 541
精华内容 216
关键字:

java封装array

java 订阅