程序 = 逻辑 + 数据,数组是存储数据的强而有力的手段。 ——闫学灿
一维数组
数组的定义
// int[] a;//定义
// a=new int[10];//初始化
int[] a=new int[10],b;//边定义边初始化,b也是数组,但是没有初始化,是一个空数组
float[] f = new float[33];
double[] d = new double[123];
char[] c = new char[21];
String[] strs = new String[10];//定义一个长度为10的String数组
数组的初始化
//也可以直接初始化数组里的值
int[] a = {0, 1, 2}; // 含有3个元素的数组,元素分别是0, 1, 2
int[] b = new int[3]; // 含有3个元素的数组,元素的值均为0
char[] d = {'a', 'b', 'c'}; // 字符数组的初始化
访问数组元素
通过下标访问数组。
public class Main {
public static void main(String[] args) {
int[] a = {0, 1, 2}; // 数组下标从0开始
System.out.printf("%d %d %d\n", a[0], a[1], a[2]);
a[0] = 5;
System.out.println(a[0]);
}
}
一维数组的范围遍历
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = new int[10];
for (int i = 0; i < 10; i++) {
arr[i]=i;
}
for(int x:arr)
System.out.println(x);
}
}
练习题1: 使用数组实现求斐波那契数列的第N项
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] f = new int[n + 1];//0到n一共是n+1个元素
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i ++ )
f[i] = f[i - 1] + f[i - 2];
System.out.println(f[n]);
}
}
练习题2:输入一个 n,再输入 n个整数。将这 n个整数逆序输出。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i ++ )
a[i] = sc.nextInt();
for (int i = n - 1; i >= 0; i -- )
System.out.printf("%d ", a[i]);
}
}
练习题3:输入 n个数,将这 n个数按从小到大的顺序输出。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i ++ )
a[i] = sc.nextInt();
for (int i = 0; i < n; i ++ )
for (int j = i + 1; j < n; j ++ )
if (a[i] > a[j]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
for (int i = 0; i < n; i ++ )
System.out.printf("%d ", a[i]);
}
}
二维数组
多维数组就是数组的数组。
public class Main {
public static void main(String[] args) {
int[][] a = new int[3][4]; // 大小为3的数组,每个元素是含有4个整数的数组。
int[][][] b = new int[10][20][30]; // 将所有元素的初值为0
// 大小为10的数组,它的每个元素是含有20个数组的数组
// 这些数组的元素是含有30个整数的数组
}
}
二维数组初始化
public class Main {
public static void main(String[] args) {
int[][] a = { // 三个元素,每个元素都是大小为4的数组
{0, 1, 2, 3}, // 第1行的初始值
{4, 5, 6, 7}, // 第2行的初始值
{8, 9, 10, 11} // 第3行的初始值,这行后面加不加都会都可以
};
for (int i = 0; i < 4; i ++ ) // 将第一行全部变成0
a[0][i] = 0;
for (int i = 0; i < 3; i ++ ) { // 输出二维数组
for (int j = 0; j < 4; j ++ ) {
System.out.printf("%d ", a[i][j]);
}
System.out.println();//回车
}
}
}
二维数组的范围遍历
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] arr = new int[10][10];
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
arr[i][j] = i*j;
}
}
for(int[] x:arr) {
for (int e : x) {
System.out.printf("%2d ",e);
}
System.out.println();
}
}
}
api
属性length:返回数组长度,注意不加小括号
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int[][] a = {
{0, 1, 2, 3},
{4, 5, 6, 7},
{8, 9, 10, 11},
};
System.out.println(a.length);
for (int i = 0; i < a.length; i++)
System.out.println(a[i].length);
}
}
Arrays.sort():数组排序
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] q = new int[n];
for (int i = 0; i < n; i++)
q[i] = sc.nextInt();
Arrays.sort(q);
System.out.println(Arrays.toString(q));//将数组转化成字符串
}
}
倒序排序
一维数组排序
需要加比较函数,数组一定要是对象,不能是基本类型,把int改成Integer
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Integer[] q = new Integer[n];
for (int i = 0; i < n; i++)
q[i] = sc.nextInt();
//Arrays.sort(q,(x,y)-> {
// return x-y;
//});//(x,y)是比较函数,->是实现匿名函数,return x-y如果x小于y,返回值是负数,x排在y的前面,x小y大,正序排序,如果x大于y,返回整数,x排在y的后面
//想实现逆序排序就写成return y-x;如果x小于y,返回值是正数,将x放在y的后面
Arrays.sort(q,(x,y)->{
return y-x;
});
System.out.println(Arrays.toString(q));//将数组转化成字符串
}
}
二维数组排序
二维数组不能直接排序,会报错
二维数组不需要把int转化成Integer,一维数组本身就是对象
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] a={
{4,5,6,7},
{0,1,2,3},
{8,9,10,11}
};
Arrays.sort(a,(x,y)->{
return x[0]-y[0];
});
System.out.println(Arrays.deepToString(a));//将数组转化成字符串
}
}
Arrays.fill(int[] a, int val):填充数组(只能初始化一维数组)
将数组里的每一个元素初始化为一个数
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = new int[10];
Arrays.fill(arr,-1);
System.out.println(Arrays.toString(arr));
}
}
Arrays.toString():将数组转化为字符串
System.out.println(Arrays.toString(arr));
Arrays.deepToString():将多维数组转化为字符串
System.out.println(Arrays.deepToString(a));
注意
java的局部变量定义完后,都是0,char是’\0’(空)
int类型定义的数组,初始化默认是0
String类型定义的数组,默认值是null
char类型定义的数组,使用UTF8字符集 给出的结果是0
double类型定义的数组,默认值是0.0
loat类型定义的数组,默认值是0.0
boolean类型定义的数组,默认值是false
c++的局部变量定义完后,都是随机值
java里的数组可以重新赋值
int[] a = {0, 1, 2};
a=new int[10];
数组不可变长
使用Arrays需要import java.util.Arrays
类与对象
String是类
String str1,str2;//st1,str2称为String这个类的对象
类名和文件名必须要一致
package可以理解为文件的路径
先写package,再写import,再写class
类名最好都大写
面向对象编程:拿东西过来做对应的事情
类(设计图)共同特征的描述
对象(具体的东西)真是存在的具体实例
先设计类,才能获得对象
在类中不给成员变量赋值,在对象中给成员变量赋值
成员变量:名词手机的品牌,价格,颜色
成员方法:动词,打电话,发短信,玩游戏
CTRL+D向下复制一行
建议一个Java文件中只写一个类
成员变量的完整定义格式是:修饰符 数据类型 变量名称=初始化值;
一般无需指定初始化值
名词用属性表示,动词用行为表示
封装
人画圆,是园自己画的
人关门,是门自己关的
张三砍了李四,是李四自己凉的
private关键字
目的是:正确的可以赋值,错误的无法赋值
把变量定义在方法中叫局部变量
把变量定义在方法的外面,类的里面,叫成员变量
this关键字
this的作用:可以区别成员变量和局部变量
当成员变量和局部变量重名时,直接输出会遵循就近原则,输出局部变量.
使用this就可以输出成员变量.
如果没重名,不用写this也可以输出成员变量
package This;
public class GirlFriend{
private int age;//成员变量,默认是0
public void method(){
int age=10;//局部变量
System.out.println(age);//就近原则,输出10
System.out.println(this.age);
}
}
package This;
public class GirlFriendTest {
public static void main(String[] args) {
GirlFriend gf1 = new GirlFriend();
gf1.method();
}
}
树
1498. 最深的根
用并查集判断一下是不是只有一个联通块,如果只有一个联通块,那么就是树
枚举每个点做一遍DFS或BFS
注意是无向边,存两次有向边
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 10010,M=N*2;//N是点,M是边
int n;
int h[N], e[M], ne[M], idx;
int p[N];
int find(int x) // 并查集
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void add(int a, int b) // 添加一条边a->b
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
int dfs(int u,int father)//当前这个点,和这个点是从哪个点来的
{
int depth=0;
for(int i=h[u];~i;i=ne[i])
{
int j=e[i];
if(j==father)continue;
depth=max(depth,dfs(j,u)+1);
}
return depth;
}
int main()
{
cin>>n;
memset(h, -1, sizeof h);
for(int i=1;i<=n;i++)p[i]=i;
int k=n;//刚开始有n个联通块
for(int i=0;i<n-1;i++)
{
int a,b;
cin>>a>>b;
if(find(a)!=find(b))
{
k--;
p[find(a)]=find(b);
}
add(a,b),add(b,a);
}
if(k>1)printf("Error: %d components",k);
else
{
vector<int>nodes;
int max_depth=-1;
for(int i=1;i<=n;i++)
{
int depth=dfs(i,-1);
if(depth>max_depth)
{
max_depth=depth;
nodes.clear();
nodes.push_back(i);
}
else if(depth==max_depth)
nodes.push_back(i);
}
for(auto v:nodes)cout<<v<<endl;
}
return 0;
}
标签:java,Scanner,int,System,数组,new,public
From: https://blog.csdn.net/2301_79203206/article/details/140429439