「java轻量级数组」java数组最大
今天给各位分享java轻量级数组的知识，其中也会对java数组最大进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
java 数组
int[] x, y;//这个是
int i,j[];//j[]也是数组 但是呢。你必须得这样才可以用他
int[] a = new int[10];这样定义 才可以用。
java中的数组
·数组是可以保存一组数据的一种数据结构，它本身也会占用一个内存地址，因此数组是引用类型 ·一个数组中只能保存一种类型的数据，可以保存基本类型，也可以保存Object。一个int,一个String是不能同时保存在一个数组内的(如果是对象型数组，注意存放的每一个对象都必须被实例化)。 ·数组的长度规定好即固定，无论其保存的数据是否填满数组 ·数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差 ·数组拥有边界检查，尝试获取不在数组范围内的值时，会抛出ArrayIndexOutOfBoundsException异常
java数组
数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。
§5.1一维数组
一、一维数组的定义
type arrayName[];
其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。例如：
int intArray[];
声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize指明数组的长度。如：
intArray=new int[3];
为一个整型数组分配3个int型整数所占据的内存空间。
通常，这两部分可以合在一起，格式如下：
type arrayName=new type[arraySize];
例如：
int intArray=new int[3];
二、一维数组元素的引用
定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。数组元素的引用方式为：
arrayName[index]
其中：index为数组下标，它可以为整型常数或表达式。如a[3]，b[i](i为整型)，c[6*I]等。下标 从0开始，一直到数组的长度减1。对于上面例子中的in-tArray数来说，它有3个元素，分别为：
intArray[0]，intArray[1]，intArray[2]。注意：没有intArray[3]。
另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
例5.1
public class ArrayTest{
public static void main(String args[]){
int i;
int a[]=newint[5];
for(i=0;i＜5;i++)
a[i]=i;
for(i=a.length-1;i＞=0;i--)
System.out.println("a["+i+"]="+a[i]);
}
}
运行结果如下：
C:\＞java ArrayTest
a[4]=4
a[3]=3
a[2]=2
a[1]=1
a[0]=0
该程序对数组中的每个元素赋值，然后按逆序输出。
三、一维数组的初始化
对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。
例如：
int a[]={1，2，3，4，5};
用逗号(，)分隔数组的各个元素，系统自动为数组分配一定空间。
与C中不同，这时Java不要求数组为静态(static)。
四、一维数组程序举例：
例5.2Fibonacci数列
Fibonacci数列的定义为：
F1=F2=1，Fn=Fn-1+Fn-2(n＞=3)
public classFibonacci{
public static void main(String args[]){
int i;
int f[]=new int[10];
f[0]=f[1]=1;
for(i=2;i＜10;i++)
f[i]=f[i-1]+f[i-2];
for(i=1;i＜=10;i++)
System.out.println("F["+i+"]="+f[i-1]);
}
}
运行结果为：
C:\＞java Fibonacci
F[1]=1
F[2]=1
F[3]=2
F[4]=3
F[5]=5
F[6]=8
F[7]=13
F[8]=21
F[9]=34
F[10]=55
例5.3冒泡法排序(从小到大)
冒泡法排序对相邻的两个元素进行比较，并把小的元素交到前面。
public class BubbleSort{
public static void main(String args[]){
int i，j;
int intArray[]={30，1，-9，70，25};
int l=intArray.length;
for(i=0;i＜l-1;i++)
for(j=i+1;j＜l;j++)
if(intArray[i]＞intArray[j]){
int t=intArray[i];
intArray[i]=intArray[j];
intArray[j]=t;
}
for(i=0;i＜l;i++)
System.out.println(intArray[i]+"");
}
}
运行结果为：
C:\＞java BubbleSort
-9
1
25
30
70
§5.2多维数组
与C、C++一样，Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。下面我们主要以二维数为例来进行说明，高维的情况是类似的。
一、二维数组的定义
二维数组的定义方式为：
type arrayName[][];
例如：
int intArray[][];
与一维数组一样，这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存，然后才可以访问每个元素。
对高维数组来说，分配内存空间有下面几种方法：
1直接为每一维分配空间，如：
int a[][]=new int[2][3];
2从最高维开始，分别为每一维分配空间，如：
int a[][]=new int[2][];
a[0]=new int[3];
a[1]=new int[3];
完成1中相同的功能。这一点与C、C++是不同的，在C、C++中必须一次指明每一维的长度。
二、二维数组元素的引用
对二维数组中每个元素，引用方式为：arrayName[index1][index2] 其中index1、index2为下标，可为整型常数或表达式，如a[2][3]等，同样，每一维的下标都从0开始。
三、二维数组的初始化
有两种方式：
1直接对每个元素进行赋值。
2在定义数组的同时进行初始化。
如：int a[][]={{2，3}，{1，5}，{3，4}};
定义了一个3×2的数组，并对每个元素赋值。
四、二维数组举例：
例5.4矩阵相乘
两个矩阵Am×n、Bn×l相乘得到Cm×l，每个元素Cij=�aik*bk (i=1..m，n=1..n)
public class MatrixMultiply{
public static void main(String args[]){
int i，j，k;
int a[][]=new int[2][3];
int b[][]={{1，5，2，8}，{5，9，10，-3}，{2，7，-5，-18}};
int c[][]=new int[2][4];
for(i=0;i＜2;i++)
for(j=0;j＜3;j++)
a[i][j]=(i+1)*(j+2);
for(i=0;i＜2;i++){
for(j=0;j＜4;j++){
c[i][j]=0;
for(k=0;k＜3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("\n***MatrixA***");
for(i=0;i＜2;i++){
for(j=0;j＜3;j++)
System.out.print(a[i][j]+"");
System.out.println();
}
System.out.println("\n***MatrixB***");
for(i=0;i＜3;i++){
for(j=0;j＜4;j++)
System.out.print(b[i][j]+"");
System.out.println();
}
System.out.println("\n***MatrixC***");
for(i=0;i＜2;i++){
for(j=0;j＜4;j++)
System.out.print(c[i][j]+"");
System.out.println();
}
}
}
其结果为：
C:\＞java MatrixMultiply
for(j=0;j＜4;j++)
System.out.print(c[i][j]+"");
System.out.println();
}
}
}
其结果为：
C:\＞java MatrixMultiply
***MatrixA***
2 3 4
4 6 8
***MatrixB***
1 5 2 8
5 9 10 -3
2 7 -5 -18
***MatrixC***
25 65 14 -65
50 130 28 -130
如果你学过线性代数，应该可以比较好地理解多维数组。
多维数组和矩阵结合紧密。
a[i][j]就是第i-1行的第j-1列的元素，因为下标是从0开始的。
比如：
一个数组：1 2 3
4 5 6
a[0][0]=1 a[0][1]=2 a[0][2]=3
a[1][0]=3 a[1][1]=5 a[1][2]=6
我推荐你看几本书：
1.Thinking in Java
2.Java 2 核心技术
3.Java2实用教程
4.面向对象程序设计与java语言
Java的数组的几种经典算法
JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。
选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。
插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。
1利用Arrays带有的排序方法快速排序
public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } }
2冒泡排序算法
public static int[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;iargs.length-1;i++){ for(int j=i+1;jargs.length;j++){ if (args[i]args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }
3选择排序算法
public static int[] selectSort(int[] args){//选择排序算法 for (int i=0;iargs.length-1 ;i++ ){ int min=i; for (int j=i+1;jargs.length ;j++ ){ if (args[min]args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }
4插入排序算法
public static int[] insertSort(int[] args){//插入排序算法 for(int i=1;iargs.length;i++){ for(int j=i;j0;j--){ if (args[j]args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }
JAVA定义一个数组，赋值8，7，6，5，2，1；
package com.shy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class TestArray {
public static void main(String[] args) {
Integer[] nums = new Integer[]{8,7,6,5,2,1};
for (Integer num1 : nums) {
System.out.print(num1 + " ");
}
System.out.println();
ListInteger numList = Arrays.asList(nums);
Collections.sort(numList);
Integer sum = 0;
for (Integer num : numList) {
System.out.print(num + " ");
sum += num;
}
System.out.println();
System.out.println("平均值为" + sum/6);
}
}
8 7 6 5 2 1
1 2 5 6 7 8
平均值为4
Java数组有哪些用法
数组：是一组相关变量的集合数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组
数据的有点不使用数组定义100个整形变量：int i1;int i2;int i3
使用数组定义 int i[100];
数组定义：int i[100];只是一个伪代码，只是表示含义的（1）一维数组
一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的，使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，声明形式一声明一维数组：数据类型 数组名[]=null;非配内存给数组：数组名=new 数据类型[长度];声明形式二声明一维数组：数据类型 [] 数组名=null;
（2）java数据类型分为两大类1.基本数据类型int、long操作的时候本身就是具体的内容引用数据类型：数组、类、接口
引用传递的就是一个内存的使用权，一块内存空间，可能有多个人同时使用
2.事例声明数组
数组的声明格式里，数据类型是数组元素的数据类型，常见的有整形、浮点型、与字符型等数组名是用来统一这组相同数据类型元素的名称，其命名规则和变量的相同数组声明后实际上是在栈内存中保存了此数组的名称，结下了是要在堆内存中配置数组所需要的内存，齐产固定是告诉编译器，所声明的数组要存放多少个元素，而new 则是命令编译器根据括号里的长度。
基本数据类型偶读有其默认值：int 0;只要是引用数据类型默认值就是null事例
声明数组的同时分配内存空间声明数组的同时非配内存数据类型 数组名[]=new 数据类型[个数]int score[]=new int[10];声明一个元素个数为10的整形数组score，同时开辟依靠内存空间工期使用java中，由于整形数据类型占用的空间为4个byte，而整个数组score可保存的元素有10个。所以上例中占用的内存共有4*10=40个字节
（3）数组的访问
数组中元素的表示方法想要访问数组里的元素可以利用索引来完成，java的数组索引标号由10开始，以一个score[10]的整形数组为例，score[0]代表第一个元素一直向下，最后一个为score[9]
（4）取得数组的长度在java中取得数组的长度（也就是数组元素的长度）可以利用数组名称.length完成，数组名称.length--返回一个int类型的数据
（5）数组的静态初始化之前的数组，所采用的都是动态初始化，所有的内容在数组声明的时候并不具体的指定，而是以默认值的形式出现静态初始化是指在数组声明后直接为数组指定具体的内容如果想要直接在声明的时候给数组赋初始值，可以采用大括号完成，只要在数组的生命格式后面加上初值的赋值即可，数据类型 数组名 []={初始值0,初始值1,初始值3，....初始值n};
范例排序，在操作中排序是比较常用的从大到小
这个时候不要被i值所迷惑 if(score[i]score[j]){
这一步主要知识为了比较，实际上完成之后输出的时候是根据j的值排序的
（6）二维数组
二维数组声明的方式和以为数组的类似，内存分配也一样是用new这个关键字
其实声明与分配内存的格式如下动态初始化数据类型 数组名[][];数组名=new 数据类型[行的个数][列的个数];
声明并初始化数组数据类型 数组名[][]=new 数据类型[行的个数][列的个数];静态初始化
（7）二维数组的存储声明二维数组score 同时开辟一段内存空间int score[][]=new int[4][3];整体数据score可保存的元素是4*3=12个，在java中，int数据类型所占用的空间为4个字节，因此该整形数组占用的内存共为4*12=48个字节事例
（8）二维数组静态初始化
用到的时候才会开辟空间，不用的（红色部分）则不开辟空间多维数组一般只是用到二维数组三维数组简单了解
java轻量级数组的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java数组最大、java轻量级数组的信息别忘了在本站进行查找喔。