如何基于java的第一位数从数组中获取整数值

我有

int number

值和

int[]numberArray

我想从

numberArray

中获取以

number

开头的所有值

我想做的是

for (int i=0;i<numbers.length;i++){
    if(numberArray[i] "starts with" number){
        System.out.print(numberArray[i]);
     }
}

---

for（inti=0；i这里是一些未经测试的java代码。但是非常糟糕的实践和糟糕的性能……无论如何都应该适合您^^

public static ArrayList<Integer> getStartingWith(int[] numbers, int key)
{
ArrayList<Integer> matching = new ArrayList<Integer>();

String keyAsString = Integer.toString(key);

for(int i = 0; i < numbers.length; i++)
{
    if(Integer.toString(numbers[i]).startsWith(keyAsString))
        matching.add(numbers[i]);
}
return matching;
}

publicstaticarraylistgetstartingwith（int[]数字，int键）
{
ArrayList匹配=新的ArrayList（）；
字符串keyaString=Integer.toString（键）；
for（int i=0；i

看看@Andreas answer。比我聪明多了！！！
使用数字中的位数。你也可以比较字符串而不是转换回int。你还应该检查数字中的位数是否大于数组中数字的位数

int number;
String stringNumber = String.valueOf(number);

for (int i = 0 ; i < numbers.length ; i++) {
    String num = Integer.toString(numbers[i]);
    if(num.length() >= stringNumber.length() && num.substring(0, stringNumber.length()).equals(stringNumber)) {
        System.out.println(numbers[i]);
    }
}

整数；
String stringNumber=String.valueOf（number）；
for（int i=0；i=stringNumber.length（）&&num.substring（0，stringNumber.length（））.equals（stringNumber））{
System.out.println（数字[i]）；
}
}
如果不想执行任何字符串转换（在比较时），可以将其保留为除法

public void findIfStartingWithDigit(int number){
  int digits = String.valueOf(number).length();
  int tmpNumber;
  for (int i = 0; i < numbers.length; i++){
    tmpNumber = numbers[i];
    while (tmpNumber >= 10*digits){
      tmpNumber = tmpNumber / 10;
    }
    if (tmpNumber == number){
      System.out.println(numbers[i]);
    }
  }
}

public void findIfStartingWithDigit（整数编号）{
int digits=String.valueOf（number）.length（）；
int tmpNumber；
for（int i=0；i=10*位）{
tmpNumber=tmpNumber/10；
}
如果（tmpNumber==数字）{
System.out.println（数字[i]）；
}
}
}
使用流的方法：

因此，该方法：


从数组中创建流
将
int
转换为
String
要使用
startsWith
方法，只过滤并保留匹配的元素
回到
int
返回包含这些值的
列表


公共静态列表intStartWidth（int[]值，int start）{
返回Arrays.stream（values）//数组上的流
.mapToObj（Integer:：toString）//转换为字符串
.filter（element->element.startsWith（Integer.toString（start））//只保留匹配的
.map（Integer:：valueOf）//转换为int
.collect（Collectors.toList（））；//列表上的程序集
}
//--------------------------------------------------------------------------------
公共静态void main（字符串[]args）{
int[]tab=newint[]{49678149872,3,49,76}；
int start=49；
列表结果=intStartWidth（选项卡，开始）；
result.forEach（System.out:：println）；
}

在这里如何使用它，获取一个
数组
，一个
int
，调用该方法，然后全部打印以检查它是否工作

这显然比用数字进行迭代或检查每个数字更容易，这里是唯一现有的方法
/。。。
//...
public static void main(String[] args) {
        // TODO Auto-generated method stub

            String x = "yourstring";
            String pattern = "0123456789";
            String piece  = "";
            StringBuilder num = new StringBuilder();
           if(startsWithDigit(x)){
               for(int i = 0; i < x.length(); i++) {
                    piece = x.substring(i,i+1);             
               if (pattern.indexOf(piece) >0){
                   num.append(piece) ;
               }
               else
                   break;
               }   
          }
           System.out.println(num.toString());
          }
          static boolean startsWithDigit(String s) {
            return Pattern.compile("^[0-9]").matcher(s).find();
    }

公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
String x=“yourstring”；
字符串模式=“0123456789”；
弦乐片=”；
StringBuilder num=新的StringBuilder（）；
if（从数字（x）开始）{
对于（int i=0；i0）{
追加数（件）；
}
其他的
打破
}   
}
System.out.println（num.toString（））；
}
静态布尔起始数字（字符串s）{
返回模式.compile（“^[0-9]”）.matcher（s.find（）；
}
如果您希望操作简单但性能未经批准：在需要时将两个int都转换为字符串，以确定其是否为真并使用字符串#startsWith@Markus，在接受答案之前检查所有答案；）请在代码中包含一些解释。代码本身并不是一个完整的答案。这并不能完全满足用户的要求not@Markus另一个中的“更简单”是什么？不要误解“新事物”和“复杂事物”；）这很容易理解，使用现有的方法使用良好的性能改进
class Test
{ static int firstDigit(int x)
    {
        // Keep dividing by 10 until it is
        // greater than equal to 10
        while(x >= 10)
            x = x/10;
        return x;
    }

    // Driver method
    public static void main(String args[])
    {
        System.out.println(firstDigit(12345));
        System.out.println(firstDigit(5432));
    }
}

public static List<Integer> intStartWidth(int[] values, int start) {
    return Arrays.stream(values)                 //Stream over the array
                 .mapToObj(Integer::toString)    //converts to String
                 .filter(element -> element.startsWith(Integer.toString(start)))  //keep only ones which match
                 .map(Integer::valueOf)          //converts to int
                 .collect(Collectors.toList());  //assembly on a List
 }

//--------------------------------------------------------------------------------

public static void main(String[] args) {
    int[] tab = new int[]{496781, 49872, 3, 49, 76};
    int start = 49;

    List<Integer> result = intStartWidth(tab, start);
    result.forEach(System.out::println);
}

//...
public static void main(String[] args) {
        // TODO Auto-generated method stub

            String x = "yourstring";
            String pattern = "0123456789";
            String piece  = "";
            StringBuilder num = new StringBuilder();
           if(startsWithDigit(x)){
               for(int i = 0; i < x.length(); i++) {
                    piece = x.substring(i,i+1);             
               if (pattern.indexOf(piece) >0){
                   num.append(piece) ;
               }
               else
                   break;
               }   
          }
           System.out.println(num.toString());
          }
          static boolean startsWithDigit(String s) {
            return Pattern.compile("^[0-9]").matcher(s).find();
    }