java數組方法

1. 如何使用 java 中的數組 java 中操作數組只需要四個步驟：1，聲明數組 語法：數據

publicclassa{
publicstaticvoidmain(String[]args){
//方法一
inta[];//聲明一個名字為a的整形數組
a=newint[3];//為名字為a的整形數組創建3個整數的存儲空間
a[0]=2;//為名字為a的整形數組中0角標的整數賦值為2
a[1]=5;//為名字為a的整形數組中1角標的整數賦值為5
a[2]=7;//為名字為a的整形數組中2角標的整數賦值為7
//方法二
intb[]=newint[3];//聲明一個名字為b的整形數組並同時為這個整形數組創建3個整數的存儲空間
b[0]=2;//為名字為b的整形數組中0角標的整數賦值為2
b[1]=5;//為名字為b的整形數組中1角標的整數賦值為5
b[2]=7;//為名字為b的整形數組中2角標的整數賦值為7
//方法三
intc[]={2,5,7}//聲明一個名字為c的整形數組並同時為這個整形數組創建3個整數的存儲空間並把0角標的整數值賦值為2，把1角標的整數值賦值為5，把2角標的整數值賦值為7
//方法四
intd[]=newint[]{2,5,7};//聲明一個名字為d的整形數組並同時為這個整形數組創建3個整數的存儲空間並把0角標的整數值賦值為2，把1角標的整數值賦值為5，把2角標的整數值賦值為7
//注意:以上方法的結果一致，只是數組名字不同
}
}

2. Java中的數組調用怎麼弄

數組的4種聲明方式：

1.先聲明再初始化

例如：

//1.聲明

int[] nums;
//初始化
nums = new int[5];

2.聲明並初始化

例如：

//2.聲明、初始化

int[] nums = new int[10];

3.創建數組同時賦值

例如：
//3.創建數組同時賦值

String[] names=new String[]{"大名","小米","夏雨荷"};

int[] ages=new int[]{21,22,21,56,13};

for (int i = 0;i < names.length;i++){
System.out.prinrln(names[i]);
}

for (int i = 0;i < ages.length;i++){
System.out.prinrln(ages[i]);
}

4.創建同時賦值，簡寫，不能寫成兩條語句

例如：

//4.創建同時賦值，簡寫，不能寫成兩條語句

String[] cities = {"上海","北京"};

(2)java數組方法擴展閱讀：

數組（Array）是有序的元素序列。若將有限個類型相同的變數的集合命名，那麼這個名稱為數組名。組成數組的各個變數稱為數組的分量，也稱為數組的元素，有時也稱為下標變數。用於區分數組的各個元素的數字編號稱為下標。數組是在程序設計中，為了處理方便， 把具有相同類型的若干元素按有序的形式組織起來的一種形式。 這些有序排列的同類數據元素的集合稱為數組。
數組是用於儲存多個相同類型數據的集合。

在C語言中， 數組屬於構造數據類型。一個數組可以分解為多個數組元素，這些數組元素可以是基本數據類型或是構造類型。因此按數組元素的類型不同，數組又可分為數值數組、字元數組、指針數組、結構數組等各種類別。

3. 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;i<args.length-1;i++){ for(int j=i+1;j<args.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;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.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;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }

4. Java中創建數組的幾種方法

Java中創建對象的四種方法 收藏Java中創建對象的四種方式
1.用new語句創建對象，這是最常見的創建對象的方法。
2.運用反射手段,調用java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。
3.調用對象的clone()方法。
4.運用反序列化手段，調用java.io.ObjectInputStream對象的 readObject()方法。
第一種最常見

5. Java數組的幾種常用操作方法

int[] num = {5,4,3,2,1};
for(int i = 0; i < num.length - 1; i++) {
for (int j = i + 1; j < num.length; j++) {
if (num[i] > num[j]) {
int tmp = num[i];
num[i] = num[j];
num[j] = tmp;
}
}
System.out.print("排序後：" + num[i]);
}

6. java中如何創建字元串數組

java中定義一個字元串數組方式如下：

1.String[] str={"AAA","BBB","CCC"};

2.String str[]={"AAA","BBB","CCC"};

string類型和其他基本類型相似，創建數組時，有上述兩種方式。

數組可以分為一維數組和二維數組；

一維數組的語法格式：

數組元素類型 數組名[ ]={數組元素的初值，。。。}

如： int sa[]={1,2,3}

二維數組聲明的語法格式：

數組元素類型 數組名[ ][ ]

如：int a[][]=new int [2[3]

都是一個原理的，自己換一下自己想要定義的數組類型就可以了。

字元串數組的創建：

String a =new String("Java");

不過推薦用ArrayList strArray = new ArrayList (); 比較靈活。

7. Java定義一個一維數組有哪幾種方法

首先: 一維數組的聲明 ; 代碼如下

int[]ary1;//Java推薦的數組聲明方式

intary2[];//不推薦,但也是正確的,C語言等使用這種方式

其次: 聲明的聲明和賦值

	//參考一
	int[]ary1={1,2,3};//聲明的時候,同時賦值
	//參考二	
	int[]ary2=newint[3];//指定數組的長度為3
		ary2[0]=1;//數組下標從0開始,依次給每個元素賦值
		ary2[1]=2;
		ary2[2]=3;
	//參考三	
	int[]ary3=newint[]{1,2,3};//注意,這里的newint[]方框里不能指定長度

最後: 注意數組的默認值;

簡單數據類型,比如boolean類型的數組,默認值就是false, int類型的數組,默認值就是0.
對象類型的數組,比如Boolean類型的數組,默認值是null,Integer類型的數組,默認值還是null

int[]ary1=newint[1];
System.out.println(ary1[0]);//輸出0
		
Integer[]ary2=newInteger[1];
System.out.println(ary2[0]);//輸出null
		
boolean[]b1=newboolean[1];
System.out.println(b1[0]);//輸出false
		
Boolean[]b2=newBoolean[1];
System.out.println(b2[0]);//輸出null

8. java中數組有沒有length()方法string沒有lenght()方法

java中數組是沒有length()方法的，只有length屬性，數組array.length返回的是該數組的長度。

字元串String是有length()方法的，str.length()返回的是該字元串的長度。

(8)java數組方法擴展閱讀

java數組常用方法：

1、聲明一個數組

String[] aArray = new String[5]；

String[] bArray = {"a","b","c", "d", "e"}；

String[] cArray = new String[]{"a","b","c","d","e"}；

2、列印一個數組

String[] aArray = new String[5]；

String[] bArray = {"a","b","c", "d", "e"}；

String[] cArray = new String[]{"a","b","c","d","e"}；

3、根據數組創建ArrayList

String[] stringArray = { "a", "b", "c", "d", "e" }；

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray))；

System.out.println(arrayList)；

4、判斷數組內部是否包含某個值

String[] stringArray = { "a", "b", "c", "d", "e" }；

boolean b = Arrays.asList(stringArray).contains("a")；

System.out.println(b)；

5、連接兩個數組

int[] intArray = { 1, 2, 3, 4, 5 }；

int[] intArray2 = { 6, 7, 8, 9, 10 }；

int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2)；

6、聲明一個內聯數組

method(new String[]{"a", "b", "c", "d", "e"})

String常用方法：

1、求字元串某一位置字元

charAt(int index)返回字元串中指定位置的字元；注意字元串中第一個字元索引是0，最後一個是

length()-1。

例如：

String str = new String("asdfzxc")；

char ch = str.charAt(4)；//ch = z

2、提取子串

用String類的substring方法可以提取字元串中的子串，該方法有兩種常用參數：

1)substring(int beginIndex)該方法從beginIndex位置起，從當前字元串中取出剩餘的字元作為一

個新的字元串返回。

2)substring(int beginIndex, int endIndex)該方法從beginIndex位置起，從當前字元串中取出到

endIndex-1位置的字元作為一個新的字元串返回。

例如：

String str1 = new String("asdfzxc")；

String str2 = str1.substring(2)；//str2 = "dfzxc"

String str3 = str1.substring(2,5)；//str3 = "dfz"

3、字元串比較

1)compareTo(String anotherString)該方法是對字元串內容按字典順序進行大小比較，通過返回的

整數值指明當前字元串與參數字元串的大小關系。若當前對象比參數大則返回正整數，反之返回負

整數，相等返回0。

2)compareToIgnore(String anotherString)與compareTo方法相似，但忽略大小寫。

3)equals(Object anotherObject)//比較當前字元串和參數字元串，在兩個字元串相等的時候返回

true，否則返回false。

4)equalsIgnoreCase(String anotherString)//與equals方法相似，但忽略大小寫。

例如：

String str1 = new String("abc")；

String str2 = new String("ABC")；

int a = str1.compareTo(str2)；//a>0

int b = str1.compareToIgnoreCase(str2)；//b=0

boolean c = str1.equals(str2)；//c=false

boolean d = str1.equalsIgnoreCase(str2)；//d=true

4、字元串連接

concat(String str)將參數中的字元串str連接到當前字元串的後面，效果等價於"+"。

例如：

String str = "aa".concat("bb").concat("cc")；

相當於String str = "aa"+"bb"+"cc"；

9. Java中數組的定義與使用方法

Java中數組的定義與使用方法:
1、數組的定義
語法有兩種：
type arrayName[];
type[] arrayName;
type 為Java中的任意數據類型，包括基本類型和組合類型，arrayName為數組名，必須是一個合法的標識符，[ ] 指明該變數是一個數組類型變數。
例如：
int demoArray[];
int[] demoArray;
這兩種形式沒有區別，使用效果完全一樣，讀者可根據自己的編程習慣選擇。
注意：Java在定義數組時並不為數組元素分配內存，因此[ ]中無需指定數組元素的個數，即數組長度。而且對於如上定義的一個數組是不能訪問它的任何元素的，開發者必須要為它分配內存空間，這時要用到運算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize 為數組的長度，type 為數組的類型。如：
demoArray=new int[3];//為一個整型數組分配3個int 型整數所佔據的內存空間。
2、數組的初始化
可以在聲明數組的同時進行初始化（靜態初始化），也可以在聲明以後進行初始化（動態初始化）。例如：
// 靜態初始化
// 靜態初始化的同時就為數組元素分配空間並賦值
int intArray[] = {1,2,3,4};
String stringArray[] = {"", "", "網路知道"};
// 動態初始化
float floatArray[] = new float[3];
floatArray[0] = 1.0f;
floatArray[1] = 132.63f;
floatArray[2] = 100F;

3、數組的使用：
每個數組都有一個length屬性來指明它的長度，例如 intArray.length 指明數組 intArray 的長度。
【示例】寫一段代碼，要求輸入任意5個整數，輸出它們的和。
import java.util.*;
public class Demo {
public static void main(String[] args){
int intArray[] = new int[5];
long total = 0;
int len = intArray.length;

// 給數組元素賦值
System.out.print("請輸入" + len + "個整數，以空格為分隔：");
Scanner sc = new Scanner(System.in);
for(int i=0; i<len; i++){
intArray[i] = sc.nextInt();
}

// 計算數組元素的和
for(int i=0; i<len; i++){
total += intArray[i];
}

System.out.println("所有數組元素的和為：" + total);
}
}

運行結果：
請輸入5個整數，以空格為分隔：10 20 15 25 50
所有數組元素的和為：120