案例
数组
1，输入一个整数，浮点数，输入一个数组 ；
package april;
import java.util.Arrays;
import java.util.Scanner;
public class Class_3 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in) ;
while(reader.hasNext())
{
int m = reader.nextInt() ;
int [] numbers = new int[m] ;
for(int index=0;index<m;index++)
{
numbers[index] = reader.nextInt();
}
System.out.println(Arrays.toString(numbers));
}
reader.close() ;
}
}输入：
2
1 3
输出：
[1,3]案例
package 内推笔试;
import java.util.Arrays;
import java.util.Scanner;
/**
* Created by liuming on 2017/8/26.
*/
public class 滴滴 {
/**
* 给定整数序列求最大连续字串和
* <p>
* 问题描述：
* 给定无序正数序列，求连续字串最大和，例如：{-23,17,-7,11,-2,1,34}，字串为{17,-7,11,}，最大和为21
*/
public static int getTargetMax(int[] arr) {
int max = arr[0];
int tmpMax = arr[0];
for (int i = 1; i < arr.length; i++) {
if (tmpMax <= 0)
tmpMax = arr[i];
else
tmpMax += arr[i];
if (tmpMax > max) {
max = tmpMax;
}
}
return max;
}
public static void main1(String[] args) {
Scanner sc = new Scanner(System.in);
//获取输入的整数序列
String str = sc.nextLine();
String[] strings = str.split(" ");
//转为整数数组
int[] ints = new int[strings.length];
for (int i = 0; i < strings.length; i++) {
ints[i] = Integer.parseInt(strings[i]);
}
System.out.println(getTargetMax(ints));
}
/**
* 整数无序数组求第K大数
* <p>
* 问题描述：
* 给定无序整数序列，求其中第K大的数，例如{45，67，33，21}，第2大的数为45
*/
public static int getTopK(int[] arr, int k) {
Arrays.sort(arr);
return arr[arr.length - k];
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//获取输入的整数序列
String str = sc.nextLine();
String[] strings = str.split(" ");
//转为整数数组
int[] ints = new int[strings.length];
for (int i = 0; i < strings.length; i++) {
ints[i] = Integer.parseInt(strings[i]);
}
int k = sc.nextInt();
System.out.println(getTopK(ints, k));
}
}每行参数个数不确定（输入字符串分割为数组）
先用scanner.nextLine()读入字符串，再将字符串分割为字符数组或字符串数组。
import java.util.*;
public class MyScanner4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入字符串数组：");
String str;
str = sc.nextLine();
char[] ch = new char[str.length()];
for(int i=0; i<str.length(); i++) {
//用charAt();进行定位分隔
ch[i] = str.charAt(i);
System.out.println(ch[i] + " ");
}
System.out.println("END");
//读入字符串后,用空格分隔为数组
String[] strs = str.split(" ");
System.out.println(Arrays.toString(strs));
}
}每行参数个数确定
import java.util.Scanner;
public class ChooseSeat {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int n = in.nextInt(); // 读第一行的参数
int[] nums = new int[n]; // 创建数组
for(int i = 0; i < n; i++) {
nums[i] = in.nextInt(); // 不停的读入元素
}
}
in.close();
}
}矩阵
数组大小确定
package april;
import java.util.Scanner;
public class Class_4 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int m = reader.nextInt();
int n = reader.nextInt() ;
int [][] array = new int[m][n] ;
for (int i=0 ; i<m ; i++)
for(int j=0 ;j<n ;j++)
{
array[i][j]=reader.nextInt();
}
reader.close() ;
/**
* 对矩阵按行打出
*/
for (int i=0 ; i<m ; i++)
{
for(int j=0 ;j<n ;j++)
{
System.out.print(array[i][j]+" ");
}
System.out.println( );
}
}
}输入：
2 2
1 2
2 1
输出：
1 2
2 1大小 不确定
//输入一个整数矩阵，矩阵的长度和宽度不确定，可以用于输入n*n的矩阵
public void aMatrix(){
Scanner sc = new Scanner(System.in);
ArrayList matrix=new ArrayList();//整个矩阵
ArrayList alinelist;//每一列
int length=0;//一列的长度
System.out.println("请输入一个矩阵：");
//获得下一行
while (sc.hasNextLine()) {
String str = sc.nextLine();
if (str.equals(""))//输入空行则完成输入，退出循环
break;
alinelist=new ArrayList();
int pre=0;//扫描指针
int i=0;
int temp=0;
for (i = 0; i < str.length(); i++) {
if (str.charAt(i) == ' ') {
temp = Integer.parseInt(str.substring(pre, i));
alinelist.add(temp);
pre = i + 1;
}
}
temp = Integer.parseInt(str.substring(pre, i));
alinelist.add(temp);
matrix.add(alinelist);
if(length<alinelist.size())
length=alinelist.size();
}
//复制到数组中
int array [] []=new int [matrix.size()][length];
//调用函数计算数量
for(int i=0;i<matrix.size();i++){
alinelist=(ArrayList) matrix.get(i);
for(int j=0;j<alinelist.size();j++){
array[i][j]=(int)alinelist.get(j);
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}输入为一个链表
这里选用最经典的反转链表题目作为例子。
package learnACM;
import java.util.Scanner;
import java.util.Stack;
public class LinkListInput {
//题目描述
//对于一个链表 L: L0→L1→…→Ln-1→Ln,
//将其翻转成 L0→Ln→L1→Ln-1→L2→Ln-2→…
//先构建一个节点类，用于链表构建
static class LinkNode {
int val;
LinkNode next;
public LinkNode(int val){
this.val = val;
}
}
public static void main(String[] args){
//输入是一串数字，请将其转换成单链表格式之后，再进行操作
//输入描述:
//一串数字，用逗号分隔
//输入
//1,2,3,4,5
Scanner scanner = new Scanner(System.in);
//以字符串形式作为输入
String str = scanner.next().toString();
//通过分隔符将其转为字符串数组
String[] arr = str.split(",");
//初始化一个整数数组
int[] ints = new int[arr.length];
//给整数数组赋值
for(int j = 0; j<ints.length;j++) {
ints[j] = Integer.parseInt(arr[j]);
}
Stack<LinkNode> stack = new Stack<>();
LinkNode head = new LinkNode(0);
LinkNode p = head;
//链表初始化并放入stack中
for(int i = 0; i < ints.length; i++){
p.next = new LinkNode(ints[i]);
p = p.next;
stack.add(p);
}
head = head.next;
//开始链表转换
p = head;
LinkNode q = stack.peek();
while ((!p.equals(q)) && (!p.next.equals(q))) {
q = stack.pop();
q.next = p.next;
p.next = q;
p = p.next.next;
q = stack.peek();
}
q.next = null;
//输出
//1,5,2,4,3
//打印
while (head != null) {
if(head.next == null){
System.out.print(head.val);
}else{
System.out.print(head.val + ",");
}
head = head.next;
}
}
}先创建一个stack，把数组遍历放入stack。
创建头结点head，头结点指针p，查看的栈顶元素q，while循环
while ((!p.equals(q)) && (!p.next.equals(q))) {
q = stack.pop();
q.next = p.next;
p.next = q;
p = p.next.next;
q = stack.peek();
}把q的next指向空，q.next = null;
输入为一个链表（第二种方法）
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()){
String str = in.nextLine();
int k = in.nextInt();
ListNode head = new ListNode(-1);
ListNode p = head;
String[] strArray = str.split(" ");
for(int i = 0; i < strArray.length - 1; i++){
p.next = new ListNode(Integer.parseInt(strArray[i]));
p = p.next;
}
head = reverseK(head.next, k);
printList(head);
}
}
// 输出处理
private static void printList(ListNode head) {
while(head != null){
System.out.print(head.val);
if(head.next != null){
System.out.print("->");
}
head = head.next;
}
}List转Int数组 （逐个复制）*
Scanner sc = new Scanner(System.in);
ArrayList arrayList = new ArrayList<>();
while (sc.hasNext()){
arrayList.add(sc.next());//nextLine()/next()看情况使用
}List<Integer> list = new ArrayList<Integer>();
//LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
int count = list.size();
int[] aux = new int[count];
for(int i = 0; i < count; i++){
aux[i] = list.poll();
}
return aux;数组变树
这里
易错
问题：Java中nextInt()后接nextLine()读取不到数据
愿意：nextInt()函数在缓冲区中遇到“空格”、“回车符”等空白字符时会将空白字符前的数据读取走，但空白字符不会被处理掉，而nextLine()函数是在缓冲区中读取一行数据，这行数据以“回车符”为结束标志，nextLine()会把包括回车符在内的数据提走。所以nextInt()后的nextLine()函数并非读取不到数据，因为nextInt()将“回车符”留在了缓冲区，nextLine()读取时遇到的第一个字符便是“回车符”，所以直接结束了。
解决：
1.在要使用nextLine()前先调用一次nextLine()，这样留在缓冲区的“回车符”就会被处理掉，这时第二个nextLine()函数可以正常读取到数据
sc.nextline() 相当于光标换到下一行
避免在nextLine()之前调用nextInt()等函数，可以统一使用nextLine()来读取数据，之后再进行类型转换。
总结：nextInt()或者next()读取完毕并回车之后其后紧跟nextLine()，就会导致nextLine()读取到空值，因为nextLine()自动读取到’\n'，意味着遇到结束符；
有时候将字符串转为整数时，代码没问题却提示数组越界，往往是因为字符串代表的整数超过了int的最值，需要改用long。
总结
不确定数组大小可以用list再转数组
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
