Java中实现结构体数组

创建和初始化数组

方法一：使用new关键字创建数组（用new创建数组并不是好的方式）
let daysOfWeek = new Array(); //使用new关键字声明并初始化数组
daysOfWeek = new Array(7); //创建一个指定长度的数组
daysOfWeek = new Array('Sunday','Monday','Tuesday'); //直接将数组元素作为参数传递给他的构造器
方法二： 在JavaScript中只用中括号形式创建数组就行[ ]
let daysOfWeek = []; //创建一个空数组
let daysOfWeek = ['Sunday','Monday','Tuesday']; //创建并初始化数组

访问元素和迭代数组

//求斐波那契数列的前20个数，已知斐波那契数列中的前两项是1，从第三项开始，每一项都等于前两项之和
    const fibonacci = [];//创建一个空数组
    fibonacci[1] = 1; // 从数组第二个开始放斐波那契数列
    fibonacci[2] = 1;
    for(let i = 3; i < 20; i++){  //循环得到第三到第二十的数
        fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
    } 
    for (let i = 1; i < fibonacci.length; i++){// 最后循环迭代数组各个元素
        console.log(fibonacci[i]);
    }

添加元素

在JavaScript中的数组是可以修改的对象 想要添加元素就可以动态增长

在数组末尾插入元素：

1.如果想在数组末尾插入元素，只要把值赋给最后一个空位上的元素
let number = [0,1,2,3,4,5,6,7,8,9];number[number.length] = 10; //number的最后一个赋值为10

2.可以使用push方法 ，能把元素添加到数组的末尾，能添加任意个元素
number.push(11);number.push(12,13); //输出number，返回的是数组长度Array(14)

在数组开头插入元素

• 想要在数组开头插入一个新元素-1。
• 为了实现这个需求，我们首先将数组中的第一个位置腾出，把所有元素向右移一个位置。我们可以循环数组中的元素，从最后一个位开始，将对应的前一个元素（i -1）的值赋给它（i），依次处理，最后把我们想要的值赋值给索引 0 的位置。
• 我们将这段逻辑写成函数，将该方法直接添加到Array放入原型上。

Array.prototype.insertFirstPosition = function (value) {
            for (let i = this.length; i >= 0; i--) {
                this[i] = this[i - 1];
            }
            this[0] = value;
        }
        number.insertFirstPosition(-1);
        console.log(number);

使用unshift方法：

unshift方法可以直接把数值插入数组开头

number.unshift(-2);//在数组头部插入-2 number.unshift(-2,-3);//按照顺序插入

删除元素

在数组末尾删除元素

• 要删除数组里最靠后的元素，可以用pop方法
  number.pop();

在数组开头删除元素
使用shift方法：

• 要删除数组的第一个元素，可以使用shift方法实现
  number.shift();

在任意位置添加或删除元素

• 使用splice方法，简单地通过指定位置、索引，就可以删除相应位置上指定数量的元素
  number.splice(0,1); 这行代码删除了从数组索引0开始的2个元素（number[0],number[1]两个）
• 对于JavaScript数组和对象，我们还可以使用delete运算符删除数组中的元素。delete number[0]。数组位置0的值会变成undefined。所以我们还是应该使用splice、pop、或者shift方法来删除数组
• 想把数0,1插入到数组里，放在之前删除元素的位置上，可以再次使用splice
  number.splice(0,0,0,1) 第一个参数表示：想要删除或插入的元素的索引值。第二个参数是删除元素的个数（这个例子里我们目的不是删除元素，所以传入0）。第三个参数往后就是要添加到数组里的值（0,1）

二维和多维数组

JavaScript只支持一维数组，并不支持矩阵
let averageTemp = [];averageTemp[0] = [1,2,3];averageTemp[1] = [1,2,3];

迭代二维数组的元素如果想看矩阵输出，创建一个通用函数，专门输出其中的值

• 使用一个嵌套的for循环来处理，其中变量i为行，变量j为列

let averageTemp = [];
        averageTemp[0] = [1,2,3];
        averageTemp[1] = [1,2,3];
        function printMatrix(myMatrix){
            for(let i = 0; i < myMatrix.length; i++){
                for(let j = 0; j < myMatrix[i].length; j++){
                    console.log(myMatrix[i][j]);
                }
            }
        }
        console.table(averageTemp);

多维数组：

• 我们也可以用这种方式处理多维数组假设我们要创建一个3x3x3的矩阵，每一格里包含矩阵的i（行）、j（列）及z（深度)之和

const matrix3x3x3 = [];
       for(let i = 0; i < 3; i++){
           matrix3x3x3[i] = []; // 初始化每个数组
           for(let j = 0; j < 3; j++){
               matrix3x3x3[i][j] = [];
               for(let z = 0; z < 3; z++){
                   matrix3x3x3[i][j][z] = i + j + z;
               }
           }
       }
    //    用以下代码输出这个矩阵的内容
    for(let i = 0; i < matrix3x3x3.length; i++){
        for(let j = 0; j < matrix3x3x3[i].length; j++){
            for(let z = 0; z < matrix3x3x3[i][j].length; z++){
               console.log(matrix3x3x3[i][j][z]); 
            }
        }
    }

JavaScript的数组方法参考

数组合并

• concat方法：有多个数组需要合并为一个数组。我们可以迭代各个数组，然后把每个元素加入最终的数组
• concat方法可以向一个数组传递数组，元素或是对象。数组会按照指定参数顺序链接指定数组
  下面例子中顺序是：arr2、zero、arr1

const zero = 0;
      const arr1 = [1,2,3];
      const arr2 = [4,5];
      let number = arr2.concat(zero,arr1);
      console.log(number); //[4,5,0,1,2,3]

迭代器函数

• JavaScript内置了许多数组可用的迭代方法
• 假设数组中的值是从1到5；如果数组里的元素可以被2整除，函数就返回true。否则返回false

let number = [1,2,3,4,5];
    function isEven(x){
        console.log(x); //1
        return x % 2 === 0 ? true : false;//也可以写成return (x % 2 === 0 );
    }
    // ES6语法：=>箭头函数
      const isEven = x => x % 2 === 0;

• 1.用every方法迭代（every方法会迭代数组中的每一个元素，直到返回false）
• 在这个例子中1不是2的倍数所以返回false 执行结束

number.every(isEven);

• 2.用some方法迭代（与every相反 会迭代数组的每个元素 直到函数返回true）
• 在这个例子中 数组第一个偶数是2 打一个被迭代元素是1， 第二个被迭代元素是2，isEven返回true结束

number.some(isEven);//1 2 true

• 3.用forEach方法迭代：迭代整个数组，它和使用for循环结果相同

let number = [1,2,3,4,5];
    number.forEach(x => console.log(x % 2=== 0));//false true false true false

• 4.使用map方法

let number = [1,2,3,4,5];
    number.map(x => console.log(x % 2=== 0));//false true false true false

• 5.使用filter方法（返回的新数组由使函数返回true的元素组成）

let number = [1,2,3,4,5];
   const isEven = x => x % 2 === 0;
   const number2  = number.filter(isEven);
   console.log(number2); //只输出了[2,4]

• 6.使用reduse方法：（对数组中所有元素求和）

let number = [1,2,3,4,5];
    reducer = (previous,current) => previous + current;
    console.log(number.reduce(reducer));//15

• reduce() 第二参数为可选参数，会影响 reduce() 最后返回值的格式

console.log(number.reduce(reducer,5));//5+1+2+3+4+5  输出20

ES5和ES6新增的数组方法

• 1.使用for…of循环迭代

let number = [1,2,3,4,5];
       for (const n of number){
           console.log(n);
       }

for…of遍历循环number中的每一项，迭代项将赋值给变量n

• 类数组迭代

for…of可以用来迭代类数组对象。arguments是函数体内的特殊变量，包含函数的所有参数

// 写一个求和函数sum{num1,num2,.....numn}
        function sum() {
            let sum = 0;
            for (const n of arguments) {
                sum += n;
            }
            return sum;
        }
        console.log(sum(1, 2, 3, 4));//10

在每次迭代中，for…of循环遍历类数组arguments中的每一个数，并计算总和

// 数组去重
        const s = new Set([1, 2, 3, 4, 5, 4, 3, 1]);
        for (let n of s) {
            console.log(n);
        }

Set对象是值的集合，你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次，即 Set 中的元素是唯一的。

• 2.使用@@iterator对象
• iterator对象工作原理：创建一个指针对象，指向当前数据结构的起始位置，第一次调用next方法时，指针指向数据结构的第一个成员。接下来调用next方法，指针后移，直到指向最后一个成员

ES5为Array类增加了@@iterator属性，需要通过Symbol.iterator来访问

let number = [1,2,3,4,41,3];
        iterator = number[Symbol.iterator]();
        for(const n of iterator){
            console.log(n);//输出number数组中的每一项
        }

• 3.entries方法返回键值对

entries方法返回包含键值对的iterator

let number = [1, 2, 3, 4, 41, 3];
        let e = number.entries();
        console.log(e.next().value);//[0,1] 位置0的值1
        console.log(e.next().value);
        console.log(e.next().value);

• 4.Keys方法返回数组的索引

keys方法会返回number数组的索引。一旦没有可迭代的值，a.next( )就会返回一个value属性为undefined、done属性为true的对象。如果返回done属性的值为false，就意味着还有可迭代的值

let number = [1, 2, 3, 4, 41, 3];
        const a = number.keys();
        console.log(a.next());//{value: 0, done: false}

value是保存在数组索引的值；done：false表示还有可迭代的值

• 5.value方法返回数组的值

let number = [1, 2, 3, 4, 41, 3];
        const a = number.values();
        console.log(a.next());//{value: 1, done: false}

• 6.Array.from方法根据已有数组创建一个新数组

let number = [1, 2, 3, 4, 41, 3];
        let number2 = Array.from(number);
        console.log(number2);//[1, 2, 3, 4, 41, 3]

• 传入一个用来过滤值的函数

let number = [1, 2, 3, 4, 41, 3];
        let number2 = Array.from(number, x => (x % 2 == 0));
        console.log(number2);//[false, true, false, true, false, false]

• 7.使用Array.of方法根据传入的参数创建一个新数组

let number = [1, 2, 3, 4, 41, 3];
        let number3 = Array.of(1);
        // 等价于
        let number3 = [1];
        console.log(number3);//[1]

• 用该方法复制数组

let number = [1, 2, 3, 4, 41, 3];
        let number3 = Array.of(...number);
        console.log(number3);//[1, 2, 3, 4, 41, 3]

该方法和from效果是一样的。展开运算符（…）会把number数组里的值都展开成参数

• 8.使用fill方法用静态值填充数组
• 填充数组

let number = [1, 2, 3, 4, 41, 3];
        let number3 = Array.of(...number);
        // 所有位置上的值都变成1
        number3.fill(1);
        console.log(number3);//[1, 1, 1, 1, 1, 1]

• 指定开始索引填充

// 指定开始填充索引
        number3.fill(3,1)//数组中从1开始所有位置上的值都是3
        console.log(number3);// [1, 3, 3, 3, 3, 3]

• 指定开始结束位置

// 指定结束填充的索引
        number3.fill(1,3,5)//数组中3-5(不包括3）的位置都是1
        console.log(number3);//[1, 3, 3, 1, 1, 3]

• 创建数组并初始化

// 创建数组并初始化
        let num = Array(7).fill(1);
        console.log(num);//[1, 1, 1, 1, 1, 1, 1]

• 9.使用copyWithin方法
  copyWithin方法复制数组中的一系列元素到同一指定的起始位置

let number = [1, 2, 3, 4, 41, 3];
        //我们把4,41,3三个值复制到数组前三个位置
        number.copyWithin(0, 3);//把3开始不包括3 的元素复制到 0位置
        console.log(number);//[4, 41, 3, 4, 41, 3]

let number2 = [1, 2, 3, 4, 5, 6, 7];
        number2.copyWithin(1, 2, 5);//将2-5不包括2 的数复制到位置1
        console.log(number2);//[1, 3, 4, 5, 5, 6, 7]

排序元素

• 1.reverse方法数组元素反转

let number = [1, 2, 3, 4, 41, 3];
        number.reverse();
        console.log(number);//[3, 41, 4, 3, 2, 1]

• 2.sort方法对数组排序，把元素默认成字符串相互比较

let number = [1, 2, 3,11,12,13];
        number.sort((a,b) => b - a);//降序排序
        number.sort((a,b) => a - b);//升序排序

搜索

搜索有两个方法：
indexof方法返回与参数匹配的第一个元素的索引；
lastIndexof与参数匹配的最后一个元素的索引

let number = [1, 2, 3,11,12,13];
        console.log(number.indexOf(12));//输出4
        console.log(number.indexOf(10));//输出-1 因为没有10
        let number2 = [1,2,3,4,5,3,4,5];
        console.log(number2.lastIndexOf(3));//输出5 输出与之匹配的最后一个元素

输出数组为字符串

• 1.toString方法把数组所有元素输出为一个字符串

let number = [1, 2, 3,11,12,13];
        console.log(number.toString());//1,2,3,11,12,13

• 2.join方法可以用一个不同的分隔符（比如-）把元素隔开

let number = [1, 2, 3,11,12,13];
       console.log(number.join('-'));//1-2-3-11-12-13