Java Scanner类

• Scanner对象把回车,空格,tab键都看作输入结束，直接用sc.next()得到的是字符串形式 
• 在创建Scanner类的对象时,需要用System.in作为它的参数,也可以将Scanner看作是System.in对象的支持者,System.in取得用户输入的内容后,交给Scanner来作一些处理. 
• Scanner类中提供了多个方法: 

hasNext() 扫描缓冲区中是否有字符，有则返回true,继续扫描。直到扫描为空，这时并不返回false,而是将方法阻塞，等待你输入内容然后继续扫描

next():取得一个字符串; 

nextInt():将取得的字符串转换成int类型的整数; 

nextFloat():将取得的字符串转换成float型; 

nextBoolean():将取得的字符串转换成boolean型; 

•  Scanner类位于java.util包中,要加上import java.util.Scanner; 用Scanner获得用户的输入非常的方便,但是Scanner取得输入的依据是空格符,包括空格键,Tab键和Enter键.当按下这其中的任一键时,Scanner就会返回下一个输入.当你输入的内容中间包括空格时,显然,使用Scanner就不能完整的获得你输入的字符串.这时候我们可以考虑使用BufferedReader类取得输入.其实在Java SE 1.4及以前的版本中,尚没有提供Scanner方法,我们获得输入时也是使用BufferReader的.

import java.util.*;
public class ScannerKeyBoardTest
{
    public static void main(String[] args)
    {
        System.out.println("请输入若干单词，以空格作为分隔");
        Scanner sc = new Scanner(System.in);
        while(!sc.hasNext("#"))  //匹配#返回true,然后取非运算。即以#为结束符号
        {
            System.out.println("键盘输入的内容是："

                + sc.next());
        }
        System.out.println("会执行的");
    }
}

原文：https://blog.csdn.net/gao_zhennan/article/details/80562548 

// Code using Scanner Class
import java.util.Scanner;
class Differ
{
     public static void main(String args[])
     {
         Scanner scn = new Scanner(System.in);
         System.out.println("Enter an integer");
         int a = scn.nextInt();
         System.out.println("Enter a String");
         String b = scn.nextLine();
         System.out.printf("You have entered:- "
                 + a + " " + "and name as " + b);
     }
}

作者：craneyuan
链接：https://www.jianshu.com/p/5ec1777808e1
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

输出单向链表中倒数第k个结点

输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。

链表结点定义如下：

struct ListNode

{

int       m_nKey;

ListNode* m_pNext;

};

详细描述：

接口说明

原型：

ListNode* FindKthToTail(ListNode* pListHead, unsignedint k);

输入参数：

ListNode* pListHead  单向链表

unsigned int k  倒数第k个结点

输出参数（指针指向的内存区域保证有效）：

无

返回值：

正常返回倒数第k个结点指针，异常返回空指针

import java.util.Scanner;
  
class ListNode{
    public int value ;
    public ListNode next = null ;
   
    public ListNode(int value){
        this.value = value ;
    }
}
class Linklist{
    private ListNode head ;
    private ListNode tail;
    public Linklist(){
        tail=head = null ;
    }
      
    public void insert(int data){
        ListNode node = new ListNode(data) ;
        if(head == null){
            head=tail=node;
        }
        else{
            tail.next = node ;
            tail = node ;
        }
           
    }
      
     
    public ListNode FindKthToTail(Linklist link, int k) {
        if(k <0 || link == null)
            return null ;
         
        ListNode fast = head,low = head;
        int count =1;
        while( fast.next!=null&& count<k)
        {
            fast=fast.next;
            count=count+1;
        }
        //如果链表长度不够
        if(count<k)
            return null;
        while(fast.next!=null)
        {
            fast=fast.next;
            low=low.next;
        }
        return low;
    }
}
 
 
public class Main {
  
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in) ;
        while(sc.hasNext()){
            int N = sc.nextInt() ;
            Linklist link = new Linklist() ;
            for(int i = 0 ; i < N ; i++){
                int data = sc.nextInt() ;
                link.insert(data); ;
            }
            int k = sc.nextInt() ;
            ListNode node = link.FindKthToTail(link, k) ;
            if(k==0)
                 System.out.println(0);
            else{
                System.out.println(node.value);
            }
             
              
        }
        sc.close();
    }
}

/* [编程题]查找第K大的元素*/
import java.util.Scanner;
import java.util.PriorityQueue;
public class Main{
   public static int findKthLargest(int[] nums, int k) {
       // 大小为k的小根堆,比根大的数都可进入小根堆，小根堆大小最大不超过3
       // 遍历完毕，则根节点即为所求
       PriorityQueue<Integer> q = new PriorityQueue<Integer>(k);
       for (int i : nums) {
           q.offer(i);//优先队列中插入元素           
if (q.size() > k) {
               q.poll();//优先队列中删除元素，删除最大的那个  
           }
       }
     return q.peek();//都是获取但不删除队首元素，也就是队列中权值最小的那个元素
   }
  public static void main(String[] args){
      Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        str = str.substring(1, str.length() - 1);
        String[] strings = str.split(",");
        int[] arr = new int[strings.length];
        int index = 0;
        for (String s : strings) {
            arr[index] = Integer.parseInt(s);
            index++;
        }
      // 使用size为3的小根堆实现
System.out.println(findKthLargest(arr, 3));
  }
}