java數組查找元素

Ⅰ java怎麼 在數組 查找元素

1
遍歷數組判斷
2
從開始就把數組的內容按照你要查找的那個條件的順序排列存儲，然後
二分法查找
。Arrays類有相關實現，可以參考。或者可以直接用，但是注意使用條件，很重要。

Ⅱ java中怎麼實現查找某個數組里的string值

如何檢查一個未排序的數組中是否包含某個特定值，這是一個在Java中非常實用並且頻繁使用的操作。另外，這也是Stack
Overflow上面非常受關注的問題。在得票數最多的答案中，可以看到，檢查數組中是否包含特定值可以用多種不同的方式實現，但是時間復雜度差別很大。
下面，我將為大家展示各種方法及其需要花費的時間。

1.檢查數組中是否包含特定值的四種不同方法

1）使用List：

public static boolean useList(String[] arr, String targetValue) {
return Arrays.asList(arr).contains(targetValue);
}

2）使用Set：

public static boolean useSet(String[] arr, String targetValue) {
Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);
}

3）使用一個簡單循環：

public static boolean useLoop(String[] arr, String targetValue) {
for(String s: arr){
if(s.equals(targetValue))
return true;
}
return false;
}

4）使用Arrays.binarySearch()：

註：下面的代碼是錯誤的，這樣寫出來僅僅為了理解方便。binarySearch()只能用於已排好序的數組中。所以，你會發現下面結果很奇怪。

public static boolean useArraysBinarySearch(String[] arr, String targetValue) {
int a = Arrays.binarySearch(arr, targetValue);
if(a > 0)
return true;
else
return false;
}

2.時間復雜度

通過下面的這段代碼可以近似比較幾個方法的時間復雜度。雖然分別搜索一個大小為5、1K、10K的數組是不夠精確的，但是思路是清晰的。

public static void main(String[] args) {
String[] arr = new String[] { "CD", "BC", "EF", "DE", "AB"};

//use list
long startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useList(arr, "A");
}
long endTime = System.nanoTime();
long ration = endTime - startTime;
System.out.println("useList: " + ration / 1000000);

//use set
startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useSet(arr, "A");
}
endTime = System.nanoTime();
ration = endTime - startTime;
System.out.println("useSet: " + ration / 1000000);

//use loop
startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useLoop(arr, "A");
}
endTime = System.nanoTime();
ration = endTime - startTime;
System.out.println("useLoop: " + ration / 1000000);

//use Arrays.binarySearch()
startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useArraysBinarySearch(arr, "A");
}
endTime = System.nanoTime();
ration = endTime - startTime;
System.out.println("useArrayBinary: " + ration / 1000000);
}

結果：

useList: 13
useSet: 72
useLoop: 5
useArraysBinarySearch: 9

對於長度為1K的數組：

String[] arr = new String[1000];

Random s = new Random();
for(int i=0; i< 1000; i++){
arr[i] = String.valueOf(s.nextInt());
}

結果：

1
2
3
4

useList: 112
useSet: 2055
useLoop: 99
useArrayBinary: 12

對於長度為10K的數組：

String[] arr = new String[10000];

Random s = new Random();
for(int i=0; i< 10000; i++){
arr[i] = String.valueOf(s.nextInt());
}

結果：

useList: 1590
useSet: 23819
useLoop: 1526
useArrayBinary: 12

很明顯，使用簡單循環的方法比使用其他任何集合效率更高。許多開發者會使用第一種方法，但是它並不是高效的。將數組壓入Collection類型中，需要首先將數組元素遍歷一遍，然後再使用集合類做其他操作。

如果使用Arrays.binarySearch()方法，數組必須是已排序的。由於上面的數組並沒有進行排序，所以該方法不可使用。

實際上，如果你需要藉助數組或者集合類高效地檢查數組中是否包含特定值，一個已排序的列表或樹可以做到時間復雜度為O(log(n))，hashset可以達到O(1)。

Ⅲ java中如何查找數組中某個元素

public static void main(String[] args) {
//定義並初始化數組
int[] arr = {22,33,44,55,66,7,2,5,24};
//定義並初始化Scanner對象，用於獲取輸入鍵盤輸入的內容
Scanner scanner = new Scanner(System.in);
//輸出信息
System.out.print("請輸入需要查找的數字：");
//獲取鍵盤輸入要查找的數字
int target = scanner.nextInt();
//循環數組
for(int i = 0; i < arr.length; i++) {
//如果輸入的數字跟當前數組的元素的值相同
if(target == arr[i]) {
//輸入所在位置，從1開始
System.out.println(target + "位於數字的第" + (i + 1) + "位");
//結束
return;
}
}
//如果找不到的話就提示一下
System.out.println("數組中不存在數字：" + target);
}

Ⅳ java 找到二維數組指定元素的位置

Scanner sn=new Scanner(new File(path)).useDelimiter("\r\n"); 這行代碼的意思應該是指定分割符為「/r/n」吧，這個/r/n不一定是換行，用這個分割的數組元素全了空值，換個成這樣吧
Scanner sn=new Scanner(new File(path)).useDelimiter([\\s]");
這樣表示用空字元分割

還有find方法里的這行代碼
if (ss[i][j].equals(str))
因ss[i][j]的值可能是空的，直接調用equals的話可能報空指針異常
所以equals前加個if 判斷一下，如果是空就不用equals了

這是我改的代碼

package com.jhc.cglib.test;

import java.util.*;
import java.io.*;

public class ReaderFile {
public static void main(String[] args) {
ReaderFile rf = new ReaderFile();
String ss[][] = rf.getArray("C:/Users/Administrator/Desktop/111.txt");// 文件路徑
System.out.println(find(ss, "價位"));

}

public static int find(String[][] ss, String str) {
if(ss==null||ss.length==0)
return -1;
boolean flag = false;
for (int i = 0; i < ss.length; i++) {
for (int j = 0; j < ss[i].length; j++) {
if(ss[i][j]==null)
continue;
if (ss[i][j].equals(str)) {
flag = true;
System.out.print(i + 1 + "\t");
System.out.println(j + 1);
}
}
}
if (flag == false) {
return -1;
}
return -1;
}

public String[][] getArray(String path) {
String[][] x = new String[15][15];
try {
Scanner sn = new Scanner(new File(path)).useDelimiter("[\\s]");
int i = 0;
while (sn.hasNextLine()) {
String[] ss = sn.next().split(" ");
System.out.println(Arrays.toString(ss));
for (int j = 0; j < ss.length; j++) {
x[i][j] = ss[j];
}
++i;
}
} catch (Exception e) {
e.printStackTrace();
}
return x;
}
}

Ⅳ Java數組中查找

binarySearch
public static int binarySearch(Object[] a,
Object key)使用二分搜索法來搜索指定數組，以獲得指定對象。在進行此調用之前，必須根據元素的自然順序對數組進行升序排序（通過 sort(Object[]) 方法）。如果沒有對數組進行排序，則結果是不確定的。（如果數組包含不可相互比較的元素（例如，字元串和整數），則無法 根據其元素的自然順序對數組進行排序，因此結果是不確定的。）如果數組包含多個等於指定對象的元素，則無法保證找到的是哪一個。

參數：
a - 要搜索的數組
key - 要搜索的值
返回：
如果它包含在數組中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。插入點 被定義為將鍵插入數組的那一點：即第一個大於此鍵的元素索引，如果數組中的所有元素都小於指定的鍵，則為 a.length。注意，這保證了當且僅當此鍵被找到時，返回的值將 >= 0。
拋出：
ClassCastException - 如果搜索的鍵不能與數組的元素進行比較。

Ⅵ 在Java中，如何檢測一個數組中是否包含某一個數據

在Java中，檢測一個數組是否包含某一個數據，通常有四種方法：

（1）for循環

（2）轉換為List，調用Arrays.asList(arr).contains方法

（3）使用Set

（4）使用Arrays.binarySearch()方法

下面為上述四種方法的具體代碼實現：

1、使用for循環

public static boolean useLoop(String[] arr, String targetValue) {

for (String s : arr) {

if (s.equals(targetValue))

return true;

}

return false;

}

Ⅶ Java String數組里的東西怎麼取 （比如 String[] A = {1,2,3,4}）

Java數組是在Java編程中經常使用的一個類，下面是對Java數組String的使用方法：

1、Java數組的語法：String[數組下標]， Java數組的下標是從0開始的。