列入：a123x456 17960?302t5876将其中连续的数字作为一个整数，依次存放到一数组a中。例如，123放在a[0],456放在a[1]。。。。。。。。统计共有多少个整数，并输出这些数？

1. //忘了加到数组a里了，修改一下。
   
2. import java.util.ArrayList;
   
3. import java.util.regex.Matcher;
   
4. import java.util.regex.Pattern;
   
5. 
   
6. public class 取出数字 {
   
7.         public static void main(String[] args){
   
8.                 String s = "a123x456 17960?302t5876";
   
9.                 getNumber(s);
   
10.         }
    
11.         public static void getNumber(String s){
    
12.                 ArrayList<Integer> al = new ArrayList<Integer>();//定义集合，将符合正则的填入该集合中
    
13.                 String regex = "\\d+";//定义正则，有一个或多个数字则符合规则
    
14.                 Pattern p = Pattern.compile(regex);//将正则封装成对象。
    
15.                 Matcher m = p.matcher(s);//通过正则对象获取匹配器对象。
    
16.                 while(m.find())//直到没有符合要求的串时，结束while
    
17.                         al.add(Integer.parseInt(m.group()));//用group返回匹配的子序列，为String型，Integer.parseInt(string)转成int型，自动装箱，添加到al集合中。
    
18.                 Object[] a = al.toArray();//将集合变为数组
    
19.                 System.out.print("总共有"+a.length+"个数，这些数字为：");//输出
    
20.                 for(Object x : a)
    
21.                         System.out.print(x+" ");//x默认调用toString();
    
22.         }
    
23. }

复制代码

1. import java.util.ArrayList;
   
2. import java.util.regex.Matcher;
   
3. import java.util.regex.Pattern;
   
4. 
   
5. public class 取出数字 {
   
6.         public static void main(String[] args){
   
7.                 String s = "a123x456 17960?302t5876";
   
8.                 getNumber(s);
   
9.         }
   
10.         public static void getNumber(String s){
    
11.                 ArrayList<Integer> al = new ArrayList<Integer>();//定义集合，将符合正则的填入该集合中
    
12.                 String regex = "\\d+";//定义正则，有一个或多个数字则符合规则
    
13.                 Pattern p = Pattern.compile(regex);//将正则封装成对象。
    
14.                 Matcher m = p.matcher(s);//通过正则对象获取匹配器对象。
    
15.                 while(m.find())//直到没有符合要求的串时，结束while
    
16.                         al.add(Integer.parseInt(m.group()));//用group返回匹配的子序列，为String型，
    
17.                                                                                                 //Integer.parseInt(string)转成int型，自动装箱，添加到al集合中。
    
18.                 System.out.print("总共有"+al.size()+"个数，这些数字为："+al);//输出
    
19.         }
    
20. }

复制代码

1. import java.util.regex.*;
   
2. import java.util.*;
   
3. class  RegxTest
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 String str = "a123x456 17960?302t5876";
   
8.                 String reg = "\\d*";
   
9.                 int num;
   
10.                
    
11.                 TreeSet<String> ts = new TreeSet<String>();
    
12.                        
    
13.                 Pattern p = Pattern.compile(reg);
    
14. 
    
15.                 Matcher m = p.matcher(str);
    
16. 
    
17.                 while(m.find())
    
18.                 {
    
19.                         ts.add(m.group());
    
20.                
    
21.                 }
    
22. 
    
23.                 num = ts.size();
    
24.                
    
25.                 for(String s : ts)
    
26.                 {
    
27.                         if(s.equals(""))
    
28.                         {
    
29.                                 num--;       
    
30.                                 continue;
    
31.                         }
    
32.                         System.out.print(s+" ");
    
33.                 }
    
34.                 System.out.println("长度为："+num);
    
35. 
    
36.        
    
37.         }
    
38. }
    

复制代码

抛砖引玉，共同提高

1. //用正则表达式把非数字剔除
   
2. class  stringdemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 String str="nn34324huiiu23424hui123as23";
   
7.                 String[]arr=retArray(str);
   
8.                 int[]a=newArray(arr);
   
9.                 System.out.println("总共有"+a.length+"个整数");
   
10.                 for(int i=0;i<a.length;i++)
    
11.                 {
    
12.                         System.out.println(a[i]);
    
13.                 }
    
14.                
    
15.     }
    
16.         //得到字符串数组
    
17.         public static String[] retArray(String str)
    
18.         {
    
19.                 //用正则表达式把非数字剔除
    
20.         String[]buf=str.split("\\D+");
    
21.                 //考虑到如果第一位是非数字，那么切出来的第一位是空字符串
    
22.                 if(buf[0].equals(""))
    
23.                 {       
    
24.                  String[]buf1=new String[buf.length-1];
    
25.                   for(int i=0;i<buf.length-1;i++)
    
26.                  {
    
27.           buf1[i]=buf[i+1];
    
28.                  }
    
29.                  return buf1;
    
30.                 }
    
31.                 return buf;
    
32.     }
    
33.         //将字符串数组转换为整数数组
    
34.         public static int[] newArray(String[] arr)
    
35.         {
    
36.                 int[]arr1=new int[arr.length];
    
37.                 for(int i=0;i<arr.length;i++)
    
38.                 {
    
39.           arr1[i]=Integer.parseInt(arr[i]);
    
40.                 }
    
41.                 return arr1;
    
42.         }
    
43. }

复制代码