public static int getIndex(int[] arr,int a)
        {
                for(int x=0;x<arr.length;x++)
                {
                        if(arr[x]==a)
                                return x;
                }
                return -1;
        }

一个整形数组，如{8,6,4,2,4,7,8,1,8,5,8,8},用上述方法查找8，查找的是8第一次出现的位置，
如果要查找8在此数组中出现的其他位置，或所有位置，该怎么办呢？

1. import java.util.Iterator;
   
2. import java.util.LinkedList;
   
3. import java.util.List;
   
4. 
   
5. public class GetIndex {
   
6.         public static void main(String[] args) {
   
7.                 int[] a={1,2,3,1,3,14,4,6,1};
   
8.                 getIndex(a, 1);
   
9.         }
   
10. 
    
11.         static void getIndex(int[] arr, int a) {
    
12. 
    
13.                 List l=  new LinkedList();
    
14.                 for (int x = 0; x < arr.length; x++) {
    
15.                         if (arr[x] == a) {
    
16.                                 l.add(x);
    
17.                         }
    
18. 
    
19.                 }
    
20.                 Iterator<Integer> i=l.iterator();
    
21.                 while (i.hasNext()) {
    
22.                         Integer integer = (Integer) i.next();
    
23.                         System.out.println(integer);
    
24.                        
    
25.                 }
    
26.                
    
27.         }
    
28. }

复制代码

我是这样实现的不知道有没有帮到你

谢谢大家，会了

可以设置一个集合，直接add（）添加很方便，当然也可以定义一个数组，然后把位置存进数组也行
下面给出存进list集合的办法
public static List getIndex(int[] arr, int a) {
  List list=new ArrayList();
  for (int x = 0; x < arr.length; x++) {
   if (arr[x] == a){
    list.add(new Integer(x));
   }
  }
  return list;
}
最后结果返回一个list集合，取出就可以看到所有位置了

1. package com.aduvm.practice;
   
2. 
   
3. public class FInd {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.             int[] a =  {8,6,4,2,4,7,8,1,8,5,8,8};
    
11.         int[] arrArguments = new int[getIndex(a,8).length];  //建立与返回数组长度一样的数组
    
12.         arrArguments = getIndex(a,8);
    
13.         for(int arrArgument:arrArguments)  //输出记录
    
14.         System.out.println( arrArgument);
    
15. 
    
16.                
    
17.         }
    
18.         public static int[] getIndex(int[] arr,int a)
    
19.         {
    
20.                     int i = 0;  
    
21.                     int[] arrIndex = new int[arr.length];  //用于记录索引
    
22.                 for(int x=0;x<arr.length;x++)
    
23.                 {
    
24.                         if(arr[x]==a){
    
25.                                 arrIndex[i] = x;  //记录相同的值
    
26.                                 i++;
    
27.                         }
    
28.                 }
    
29.                 return arrIndex;  //程序不完整，仅供参考 ,返回值为0怎么处理？
    
30. 
    
31.         }
    
32. 
    
33.   
    
34. 
    
35. 
    
36. }
    

复制代码

public class Aaa {
public static void main(String[] args){
  int[] a =  {8,6,4,2,4,7,8,1,8,5,8,8};
  int b = getIndex(a, 8);
  System.out.println(b);
}

public static int getIndex(int[] arr,int a)
    {
  int count = 0;
            for(int x=0;x<arr.length;x++)
            {
                    if(arr[x]==a)
                     count++;------------------------------>加入一个计数器，符合条件count++
            }
            return count;
    }

}
这个是通过计数器的方法  更为简单！

这是我的代码，先在getIndex中加入StringBuilder容器，判断，如果arr[x]== 8 ，就把它存到容器中去。最后，通过获取StringBuilder容器的长度来获取8出现的次数！
        public static void main(String[] args){
                int[] a =  {8,6,4,2,4,7,8,1,8,5,8,8};
                StringBuilder b = getIndex(a, 8);
                System.out.println(b.length());------------------------------>最后通过获取容器的长度来判断8出现的次数
        }
        
        public static StringBuilder getIndex(int[] arr,int a)
    {
                StringBuilder sb = new StringBuilder();------------------------------->加入容器，如果符合条件就装入到容器中
            for(int x=0;x<arr.length;x++)
            {
                    if(arr[x]==a)
                            sb.append(arr[x]);
            }
            return sb;
    }

          public static void main(String[] args)
        {   
           int[] a =  {8,6,4,2,4,7,8,1,8,5,8,8};
           getIndex(a,8);
           System.out.println(sb.toString());
               
        }
        static StringBuilder sb = new StringBuilder();
        public static int getIndex(int[] arr,int a)
        {
                for(int x=0;x<arr.length;x++)
                {
                        if(arr[x]==a){
                                sb.append(x);
                                sb.append(',');
                        }   
                }
                return -1;
        }

在你的基础上简单写了个，有点马虎 你看看能不能用

那么你就定义一个容器计数器将每次匹配的角标保存到容器内！这样容器就能获得你所需要的内容！