寒假Java练习

henulmh

已于 2024-01-11 21:33:49 修改

阅读量408

点赞数 5

文章标签： java c++ 开发语言

于 2021-01-14 21:14:17 首次发布

本文链接：https://blog.csdn.net/henulmh/article/details/112638446

版权

交题时注意：不要输入package名字；类名必须为Main
java中遇到的运行错误：
（1）使用字符串s.charAt(i) 下标越界
（2）Integer.ParseInt(s) s为空字符串

1.输入输出

import java.util.Scanner;
Scanner in=new Scanner(System.in); //设置输入
int n=in.nextInt(); //输入一个int整形
String s=in.next(); //输入一个字符串（不包含空格，遇见空格/回车就停）
String ss=in.nextLine(); //输入一个字符串（包含空格，遇见回车就停）
//java中没有获取单个字符的办法
//若要获取单个字符则还是读取一个字符串 char ch=s.charAt(0) 即可

//如果在输入一个整型之后紧接着输入一个nextLine()
//注意要在中间再加一个scanner.nextLine() 类似C++里面的的getchar()

//如果题目上说是多组输入，类似于C++中的 while(cin)
Scanner in=new Scanner(System.in);
int a,b,c; 
while(in.hasNext()) //多组输入
{	
	a=in.nextInt();
	b=in.nextInt();
	c=in.nextInt();
	System.out.printf("%d\n",a+b+c);
}

//更快的输入，缺点是不能读入整型，只能读入一行然后Split切割再进行转换
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String s1 = in.readLine(); // 读入一行
string s2[] = s1.split(" "); // 使用Split通过空格分割读入的一行字符串，存在s2中
  //多组输入
  while((s=in.readLine())!=null)
  {
			
  }
//更快的输出
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
然后:
out.println(); //即可输出
注意最后需要带上: 
out.flush();

2.字符串遍历

int sum=0;
for (int i = 0; i < s.length(); i++) {
	sum+=s.charAt(i)-'0'; //通过s.charAt(i)获取每一个字符 字符->数字与C一样
}

//字符数组的遍历
char[] c=new char[105];
sum=0;
for (int i = 0; i < c.length; i++) {   //获取字符数组长度不需要括号
	sum+=c[i]-'0'; //通过下标获取每一个字符 字符->数字与C一样
}

3.字符串与整型的相互转换

1.int型转字符串
//（1）String s=Integer.toString(n);
（2）String s=n+""; //极其方便
2.字符串转int型
（1）int t=Integer.parseInt(s); //非常常用，如果使用BufferedReader读入
（2）如果是字符串遍历过程中单个数字字符转整型的话  s.charAt(i)-'0' 即可。但不存在+'0'
3.字符串转Double类型
	d=Double.parseDouble(s);

4.数组的定义

int[] i=new int[5];
int[] i={0,1};
char[] s=new char[5];
char[] s={'a','b'};
string[] str=new string[15];
string[] str={"aaa","bbb","ccc"};

5.Java中的 “结构体”


import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class node{  //用类来进行封装
	String name;
	String id;
	int score;
	public node(String name, String id, int score) { // 编写构造方法便于新建结构体实例
		this.name = name;
		this.id = id;
		this.score score;
	}
}

class px implements Comparator<node>{ //自定义类，通过Comparator设置排序规则
	
	public int compare(node a,node b) {
		return b.score-a.score;  //b-a 代表降序， a-b代表升序
	}
	//如果是按照double类型的数据进行排序，则不能向上述那样写，应如下
	public int compare(node a, node b) {
		if(a.price<b.price) //price为double类型，此处是降序
			return 1;   //第二个(即b)比较大时返回1代表降序  第一个即(a)比较大时返回1则代表升序
		else if(a.price==b.price)
			return 0;
		return -1;
	}
	//如果是按照字符串类型进行排序
	public int compare(node a,node b)
	{
		return a.id.compareTo(b.id); //与上面类似，a在前是升序，b在前是降序
	}

}

public class test1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		node[] q=new node[1005];
		for(int i=0;i<n;i++) {
			q[i]=new node(); //类对象必须初始化！！，分配内存空间
			q[i].name=sc.next();
			q[i].id=sc.next();
			q[i].score=sc.nextInt();
		}
		//Arrays是一个专门对“数组”进行排序的类
		Arrays.sort(q,0,n,new px()); //利用Arrays进行排序
		//第2 3 参数为指定范围[0,n)，第4个参数为排序规则
		//排序的数组中的类型 必须与 px中的类型保持一致！ Integer与int不是一类的！！！
		System.out.printf("%s %s\n", q[0].name,q[0].id);
		System.out.printf("%s %s\n", q[n-1].name,q[n-1].id);
		
	}
}

6.ArrayList（对应C++的vector）

//定义
ArrayList<Integer> a = new ArrayList<Integer>();
//添加元素
a.add(1); //在末尾插入1   
a.add(1,3); //在下标为1插入3
//删除元素
a.remove(1);  //删除下标为1的元素
a.remove(Integer.valueOf(1));  //删除值为1的元素
//修改元素
a.set(0,1);   //将下标为0的元素的值改成1
//访问元素
a.get(1) //访问下标为1的元素
//遍历
for (int i = 0; i < a.size(); i++) 
{
     System.out.println(a.get(i));
}
//排序
Collections.sort(a); //运用Collections类
还可以加入排序规则
Collections.sort(a,new px()); //在自定义类px中设定规则

//二维数组 类似 vector<int> v[1005]
 ArrayList[] arrayList = new ArrayList[n];
 for (int i = 0; i < n; i++) {
      arrayList[i] = new ArrayList<Integer>();
 }

7.Queue或者ArrayDeque（对应C++的queue）

Queue<Integer> queue = new ArrayDeque<Integer>();
queue.offer(1);//成功返回true，失败返回false,别写成push！！
queue.offer(2);
queue.offer(3);
System.out.println(queue.peek());//类似于C++中queue的front()，返回第一个元素
while (!queue.isEmpty()) {
    System.out.println(queue.poll());//跟C++中的queue()一样可以删除第一个元素，但是会返回它，不像C++中是void的
}

8.ArrayDeque（对应C++的stack，在Java中queue与stack都可以对应这个类）

ArrayDeque<Integer> stack = new ArrayDeque<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.peek());//类似于C++中stack的top()，返回栈顶元素
while(!stack.isEmpty()){
    System.out.println(stack.pop());//跟C++中的pop()一样可以弹出栈顶元素，但是会返回它，不像C++中是void的
}

9.HashMap（对应C++的map）

//这里使用的是HashMap，是无序的，对应标准C++的unordered_map
//若要使用有序的，则用TreeMap
//TreeMap<Integer, Integer> m = new TreeMap<Integer, Integer>();
//定义
HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
//是否存在键
m.containsKey(a)
//添加元素
m.put(1, 111);
m.put(s, m.getOrDefault(s, 0)+1); // 一般常用这个，当要添加的key在map中不存在时，为其赋值1，若已存在则累加1
//访问元素
m.get(1);
//根据key删除元素
m.remove(1);
m.clear();
//计算大小
m.size();
//修改， C++的map可以直接 m['a']++ 这样修改，但hashmap不行
m.replace(s, 5); // 将键为ch的值改为5
//用for-each遍历 输出 key 和 value
for (Integer i : m.keySet()) 
{
     System.out.println("key: " + i + " value: " + m.get(i));
}
// 可通过entrySet() 遍历所有键值对
for(Map.Entry<String, Integer> entry : m.entrySet())
{
	// 通过getkey()获取键 通过getvalue()获取值
    entry.getKey()
    entry.getValue()
}
//如果key存在的话则取此key对应的value值，不存在的话取0

10.HashSet（对应C++的set）

HashSet<String> sites = new HashSet<String>();
//添加元素
sites.add("Taobao");
//判断元素是否存在
sites.contains("Taobao") //返回true false
//删除元素
sites.remove("Taobao");
sites.clear();
//计算大小
sites.size();
//迭代
for (String i : sites) {
    System.out.println(i);
}
//若要有序则可使用TreeSet，默认升序排序，可自定义设置排序规则
TreeSet<node> ts=new TreeSet<node>(new px()); //px是定义的一个执行Comparator接口的一个类

11.在main函数中调用的函数必须为static定义的函数，运用的全局变量也必须是static定义的。如下素数线性筛函数：

package myjava;
import java.util.Scanner;
public class Main {

	 static int[] prime=new int[1000005];
	 static boolean[] flag=new boolean[1000005];
	 static int tot=0;
	 public static void getprime()
	 {
		for(int i=2;i<1000000;i++)
		{
			if(!flag[i])
			{
				prime[++tot]=i;
			}
			for(int j=1;j<=tot;j++)
			{
				if(i*prime[j]>1000000)
					break;
				flag[i*prime[j]]=true;
				if(i%prime[j]==0)
					break;
			}
		}
	 }
	 public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		getprime();
		for(int i=1;i<=tot;i++)
		{
			System.out.println(prime[i]);	
		}
	 }
}

12.StringBuilder

StringBuilder s=new StringBuilder();
//获取字符串长度
s.length()
//在尾部添加
s.append("123");
//在指定位置插入
s.insert(1,"aaa"); //在下标为1出插入"aaa"
//删除指定区间
s.delete(1,3); //删除区间[1,3) 即下标1-2
//获取指定字符
s.charAt(i) //获取下标为i的字符
//设置指定字符
s.setCharAt(i)
//获取指定子串出现的位置
int s=s.indexOf("a"); //"a"在s中第一次出现的位置
int e=s.lastIndexOf("a"); //"a"在s中最后一次出现的位置
//截取指定区间子串
s.substring(0,3); //截取区间[0,3) 即下标0-2
//修改指定区间子串
s.replace(0,5,"bbbb");// 将区间[0,5)的子串替换为"bbbb"，下标0-4 
//字符串反转
s.reverse();
//StringBuilder类型转String类型
s.toString()即可
//判断两个StringBuilder类型的对象相等
s1.compareTo(s2)  //注意不要用equals，不可用

13.String
与StringBuilder最大区别是：
String是静态的，执行一些操作后需要另一个字符串来承接
StringBuilder是动态的，执行s.replace()、s.reverse()等，s自身会直接变化

//字符串查找
int a=s.indexOf("")
int a=s.lastIndexOf("")
boolean a = s.contains(b) // 判断b是否是a的子串
//获取指定索引位置的字符
char ch=s.charAt(i)
//获取子字符串
String ss=s.subString(start,end) //不包含end
//去除首尾空格
String ss=s.trim(); 
//字符串替换
String ss=s.replace("a", "b");//将s中所有的a变成b
//判断字符串的开始与结尾
s.startsWith("") //用于判断当前字符串对象的前缀是否是指定的字符串。
s.endsWith("")//用于判断当前字符串是否以指定的字符串结束
//判断字符串是否相等
s1.equals(s2) //注意不是直接 s1==s2
//按字典顺序比较两个字符串
s1.compareTo(s2); //若 s1在s2之前 返回-1 
                  //若 s1在s2之后 返回1
                  //若 s1与s2相等 返回0     注意不是直接> <
//字母大小写转换
String s2=ss1.toUpperCase();
String s3=ss1.toLowerCase();
//字符串分割
String[] s1=s.split(" ");
//把字符串转化为相应的数值，若是StringBuilder类型，则需要用toString转换一下再转数值型
Integer.parseInt(s)
Long.parseLong(s)
Double.parseDouble(s)
//字符串转为字符数组
char[] c = s.toCharArray();
String ss=new String(c); //字符数组转换为字符串
字符串的排序就是用上面两句联合实现的！
String s=sc.next();
char[] ch=s.toCharArray();
Arrays.sort(ch); //利用Arrays对字符数组进行排序，排完后再将ch转为字符串s
s=new String(ch);

String不能直接通过下标修改单个字符
StringBuilder可以通过setCharAt进行修改

14.大数类BigInteger

1.加法
  BufferedReader sc= new BufferedReader(new InputStreamReader(System.in));
  String a=sc.readLine();
  String[] s=a.split(" ");
  BigInteger A=new BigInteger(s[0]); //初始化，读入的是字符串
  BigInteger B=new BigInteger(s[1]);
  BigInteger c=A.add(B);
  System.out.println(c);
2.减法
  BigInteger c=A.subtract(B); //其余均一样
3.乘法
  BigInteger c=A.multiply(B); //其余均一样
4.除法 
  BigInteger c=A.divide(B);  //其余均一样
5.取余
  BigInteger c=A.mod(B);  //其余都一样
6.大整数相除 得 商和余数
  BufferedReader sc= new BufferedReader(new InputStreamReader(System.in));
  String a=sc.readLine();
  String[] s=a.split(" ");
  BigInteger A=new BigInteger(s[0]); 
  BigInteger B=new BigInteger(s[1]);
  BigInteger[] ss=A.divideAndRemainder(B); //返回一个数组，分别为商和余数
  System.out.println(ss[0]+" "+ss[1]); 
7.补充
  BigInteger c = A.gcd(B); //获取A和B的最大公因数
  BigInteger c = A.max(B); //获取A和B中的最大值
  BigInteger c = A.min(B); //获取A和B中的最小值
  BigInteger c = A.modPow(B, mod); //(A^B)%mod
  上面的A和B都是BigInteger类似类型的，但有时我们是一个大数与一个不是很大的数进行	
  的运算，将普通数转换为大数：BigInteger.valueOf(n);

15.进制转换

//十进制转换为其他进制
int a=12345;
String s3=Integer.toString(a,i); //将a转换为i进制
//其他进制转换为十进制
int a=Integer.valueOf(b,i); //将i进制数b转换为十进制
int y4=Integer.valueOf("101",7); //将7进制下的 101 转换为十进制数y4

16.Math类

1.求最大值
Math.max(a,b);
2.求最小值
Math.max(a,b);
3.求平方根
Math.sqrt(a);
4.求绝对值
Math.abs(a);
5.求幂
Math.pow(a,b);
6.取整
Math.ceil(a) //向上取整  返回double
Math.floor(a) //向下取整  返回double
Math.round(a) //四舍五入取整 返回int
7.三角函数
Math.sin(double a);
Math.cos(double a); 
Math.tan(double a);

Arrays.fill(a,0) //快速初始化填充一个数组

优先队列

PriorityQueue<Integer> q=new PriorityQueue<Integer>(new px());
q.offer(3);
q.offer(2);
q.offer(1);
while(!q.isEmpty())
{
	System.out.println(q.peek());
	q.poll();
}

双端队列

Deque<Integer> deque = new LinkedList<Integer>();
或者
LinkedList<Integer> deque = new LinkedList<Integer>();
// 增
deque.addFirst("Element 1 (Head)");
deque.addLast("Element 2 (Tail)");
deque.offerFirst("Element 3 (Head)");
deque.offerLast("Element 4 (Tail)");
// 查
Integer firstElement = deque.getFirst();
Integer lastElement = deque.getLast();
Integer firstElement = deque.peekFirst();
Integer lastElement = deque.peekLast();
// 删
Integer removedElement = deque.removeFirst();
Integer removedElement = deque.removeLast();
Integer removedElement = deque.pollFirst();
Integer removedElement = deque.pollLast();
// 遍历
for(Integer e : deque){
    System.out.println(e);
}

如果要转成 ArrayList
直接 new ArrayList<>(deque)