7. Java本项目知识基础---上篇
Java本项目知识快速入门
1. idea项目打开、关闭、复制
正常关闭：
正常打开：
正常复制：
2. idea快捷键
保存：ctrl+s
撤销：ctrl+z
还原：ctrl+shift+z
复制:ctrl+c
粘贴:ctrl+v
快速复制粘贴:ctrl+d
删除行:ctrl+y
文件内容查找:ctrl+f
文件内容替换:ctrl+r
项目级别查找:ctrl+shift+f
1.项目级别查找:ctrl+shift+f 使用
- 生成快捷返回值:ctrl+alt+v
- 项目级别快速查找任何内容：两次ctrl
2.在左侧直接输入字母，就可以根据字母寻找到指定文件
3. 主程序执行两种方法
测试开启：
开发开启：
4.Java基础语法
1. 基本数据类型
在Java中，如果需要向内存中保存数据。
定义变量：可以随时修改的空间。
定义常量：一旦赋值不可改变的内容。 （若有某个内容一旦确定，不需要更改。
访问数据平台的地址、数据平台的令牌）
public static void main(String[] args) {
//定义变量
int a = 10;
System.out.println(a);
a = 20;
System.out.println(a);
a = 30;
System.out.println(a);
a = a+1;
System.out.println(a);
//定义常量
final int B = 10;
System.out.println(B);
//B=20; //常量一旦赋值，不能被二次赋值
}
public static void main(String[] args) {
//整数类型
byte a = 10;
//byte a1 = 128;
int b = 128;
//int b1 = 2200000000;
long c = 2200000000L;
System.out.println(a);
System.out.println(b);
System.out.println(c);
//浮点型
float f = 10.55F;
double b2 = 10.55;
System.out.println(f);
System.out.println(b2);
//字符型
char x = 'a';
char x1 = '你';
//char x2 = '你好';
//布尔型
boolean bb = true;
boolean bb2 = false;
System.out.println(bb);
System.out.println(bb2);
}
2. 引用数据类型&自定义引用数据类型
1.默认值
:
public class Demo4 {
static int a;
static boolean b;
static double c;
static char d;
static String str;
public static void main(String[] args) {
//基本数据类型默认值
System.out.println(a);//0
System.out.println(b);//false
System.out.println(c);//0.0
System.out.println(d);// (空字符)
//引用数据类型默认值 全为null
System.out.println(str);//null
}
}
2.使用格式:
数据类型 变量名 = new 数据类型();
public static void main(String[] args) {
String str = new String("你好世界");
System.out.println(str);
}
3.常见类型:String
基本数据类型的封装类：
| 基本数据类型 | 基本数据类型的封装类(引用数据类型) |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
4.字符串转其他基本数据类型
public static void main(String[] args) {
String a = "10";
String b = "10.55";
String c = "2200000000";
String d = "true";
//字符串转其他类型
int a1 = Integer.parseInt(a);
System.out.println(a+1);//101
System.out.println(a1+1);//11
double b2 = Double.parseDouble(b);
System.out.println(b2);
long c2 = Long.parseLong(c);
System.out.println(c2);
boolean d2 = Boolean.parseBoolean(d);
System.out.println(d2);
}
5.自定义引用数据类型
创建出来的Java文件，Java类，都是自定义的引用数据类型。
public class Demo7 {
public static void main(String[] args) {
Student s1 = new Student();
}
}
6.运算符、if与循环
运算符
四则运算符：+ - * / % ++ –
public static void main(String[] args) {
//四则运算符
//数字运算:数学加法
System.out.println(10+1);//11
//字符串运算：字符串拼接
System.out.println("10"+1);//101
System.out.println(10-1);//9
System.out.println(-10);//-10
//整数乘除法：两端都是整数，强制去除小数位
System.out.println(10*5);//50
System.out.println(10/5);//2
System.out.println(5/2);//2
//小数乘除法：两端有一端是小数，保留结果的小数位
System.out.println(10.0*5);//50.0
System.out.println(10.0/5);//2.0
System.out.println(5.0/2);//2.5
// % 取余数， 不和0进行%
System.out.println(5%2);//1
System.out.println(4%2);//0
//判断是否是2的整数倍， 判断是奇数还是偶数
int a = 10;
System.out.println(++a);//11
System.out.println(a++);//11
System.out.println(a);//12
System.out.println(--a);//11
System.out.println(a--);//11
System.out.println(a);//10
}
关系运算符：两个数字类型的大小关系
关系运算符：两个数字类型的大小关系
如果式子成立，返回true
如果式子不成立，返回false
== 两端相等，式子成立
>
<
>=
<=
!= 两端不相等，式子成立
public class Demo9 {
public static void main(String[] args) {
System.out.println(10==10);//true
System.out.println(10==11);//false
System.out.println(10!=10);//false
System.out.println(10!=11);//true
System.out.println(10>5);//true
System.out.println(10>11);//false
System.out.println(10<5);//false
System.out.println(10<11);//true
System.out.println(10>=10);//true
System.out.println(10>=11);//false
System.out.println(10<=10);//true
System.out.println(10<=11);//true
}
}
逻辑运算符： && || !
对布尔值进行运算
&& 两端都为true，结果才为true
|| 两端都为false，结果才为false
! 取反
public class Demo10 {
public static void main(String[] args) {
System.out.println(true&&true);//true
System.out.println(false&&true);//false
System.out.println(true&&false);//false
System.out.println(false&&false);//false
System.out.println(true||true);//true
System.out.println(false||true);//true
System.out.println(true||false);//true
System.out.println(false||false);//false
System.out.println(!true);//false
System.out.println(!false);//true
}
}
三元运算符：
布尔表达式?结果1:结果2;
public class Demo11 {
public static void main(String[] args) {
System.out.println(10>=10?"符合":"不符合");//符合
System.out.println(10>=11?"符合":"不符合");//不符合
int age = 18;
System.out.println(age>=18?"成年了":"未成年");//成年了
}
}
7.If
条件判断分支语句。
switch...
语法格式：
if(表达式){
//代码块1
}
if(表达式){
//代码块1
}else{
//代码块2
}
if(表达式){
//代码块1
}else if(表达式){
//代码块2
}else{
//代码块N
}
public class Demo12 {
public static void main(String[] args) {
int score = 75;
if(score>=60){
if(score>=80){
System.out.println("优秀");
}else if(score>=70){
System.out.println("良");
}else{
System.out.println("及格");
}
}else{
System.out.println("不及格");
}
}
}
8.循环
重复执行某些代码。
for while do-while。。。。
快捷键：fori
public class Demo13 {
public static void main(String[] args) {
/*System.out.println("hello");
System.out.println("hello");
System.out.println("hello");*/
//fori
for (int i = 1; i <=3 ; i++) {
System.out.println(i);
}
//倒序
for (int i = 3; i>=1 ; i--) {
System.out.println(i);
}
}
}
3. 数组&集合类型
1.数组
知道要保存多少个数据，保存多个相同数据类型。
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private String name;
private String sex;
}
public static void main(String[] args) {
//整数数组
int[] arr1 = {10,20,30};//数组长度为3
int[] arr2 = new int[5];//数组长度为5，但是每个数组位置都没有具体值。
//展示数组内容
System.out.println(arr1[0]);//10
System.out.println(arr1[2]);//30
//展示所有内容 数组名.fori
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
System.out.println(Arrays.toString(arr1));
//访问不存在索引，就会报异常：ArrayIndexOutOfBoundsException
//System.out.println(arr1[1000]);
//倒序展示所有内容 数组名.forr
for (int i = arr1.length - 1; i >= 0; i--) {
System.out.println(arr1[i]);
}
System.out.println("----");
//小数数组
double[] arr3 = {10.55,20.55,30.55};
//字符串数组
String[] arr4 = {"a1","b2","c3","d4"};
//自定义类型数组
Student[] sarr = {
new Student("小张","男"),
new Student("小明","男"),
new Student("小红","女")
};
//例如：将小张的 性别改为女
sarr[0].setSex("女");
for (int i = 0; i < sarr.length; i++) {
System.out.println(sarr[i]);
}
}
小结：
注意不可访问不存在的索引，否则会抛出索引越界的异常。
2.单列集合
List： 列表集合 （有序，有索引，可以重复）
Set： 散列集合 （无序、无索引，不可以重复）
Queue 队列
Stack 栈
ArrayList：可以理解为一个超级数组，动态改变长度。
格式
ArrayList<引用数据类型> 变量名 = new ArrayList<>();
public static void main(String[] args) {
//创建一个保存字符串的集合
ArrayList<String> list1 = new ArrayList<>();
list1.add("a1");
list1.add("a2");
list1.add("a3");
//list1.add(10);//不能保存，因为不是指定的String类型
System.out.println(list1);
//创建一个保存整数的集合
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(10);
list2.add(20);
list2.add(30);
//list2.add("aa");//不能保存，因为不是指定的Integer类型
//list2.add(2200000000L);//不能保存，因为你期待保存long类型，但这里规定只能保存Integer
System.out.println(list2);
//创建一个保存小数的集合
ArrayList<Double> list3 = new ArrayList<>();
list3.add(10.55);
list3.add(1.55);
System.out.println(list3);
//保存自定义类型集合
ArrayList<Student> slist = new ArrayList<>();
slist.add(new Student("小明","男"));
slist.add(new Student("小红","女"));
System.out.println(slist);
}
常见方法:
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list.size());//0
list.add("a1");
list.add("a2");
list.add("a3");
list.add("a4");
list.add("a5");
System.out.println(list);//[a1, a2, a3, a4, a5]
System.out.println(list.size());//5
//获取a3元素
String a3 = list.get(2);
System.out.println(a3);//a3
//判断a3元素是否存在
boolean f1 = list.contains("a3");
System.out.println(f1);//true
System.out.println(list.contains("aaa"));//false
//将a3改为a30
String str1 = list.set(2, "a30");
System.out.println(str1+"被替代了");//a3被替代了
System.out.println(list);//[a1, a2, a30, a4, a5]
//将2索引元素删除
String remove = list.remove(2);
System.out.println(remove+"被删除了");//a30被删除了
System.out.println(list);//[a1, a2, a4, a5]
//删除所有内容
list.clear();
System.out.println(list);//[]
System.out.println(list.size());//0
System.out.println(list.isEmpty());//true
}
3.遍历
逐个操作每个元素。
普通for遍历：集合名.fori
增强for遍历：集合名.for
迭代器遍历： 集合名.iterator()
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a1");
list.add("a2");
list.add("a3");
list.add("a4");
list.add("a5");
//普通for遍历 通过索引来进行遍历的 （较多）
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
//增强for遍历 无需通过索引进行遍历 （很多）
for (String s : list) {
System.out.println(s);
}
//迭代器遍历 更灵活操作，无需索引 (少)
Iterator<String> it = list.iterator();
while (it.hasNext()){
String next = it.next();
System.out.println(next);
}
}
4.特殊
遍历/迭代中如何删除：
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a1");
list.add("a2");
list.add("a3");
list.add("a4");
list.add("a5");
//在遍历中删除: a2 和 a3
//普通for遍历
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
if(s.equals("a2")||s.equals("a3")){
list.remove(i);
i--;
}
}
System.out.println(list);
ArrayList<String> list2 = new ArrayList<>();
list2.add("a1");
list2.add("a2");
list2.add("a3");
list2.add("a4");
list2.add("a5");
//增强for遍历：无法在遍历中删除 ，若强制在循环中删除，会报ConcurrentModificationException
/*for (String s : list2) {
if(s.equals("a2")||s.equals("a3")){
list2.remove(s);
}
}
System.out.println(list2);*/
ArrayList<String> list3 = new ArrayList<>();
list3.add("a1");
list3.add("a2");
list3.add("a3");
list3.add("a4");
list3.add("a5");
//迭代器遍历 更灵活操作，无需索引 (少)
Iterator<String> it = list3.iterator();
while (it.hasNext()){
String next = it.next();
if(next.equals("a2")||next.equals("a3")){
it.remove();
}
}
System.out.println(list3);
}
5.自定义类型的包含判断
在进行contains判断时，如果是自定义类型，则必须加入
@EqualsAndHashCode(of={“属性1”,“属性2”})
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
//在进行contains判断时，只要姓名相同，就是同一个人
@EqualsAndHashCode(of={"name"})
public class Student {
private String name;
private String sex;
}
import java.util.ArrayList;
public class Demo6 {
public static void main(String[] args) {
//业务：认为 只要姓名相同就是同一个人
ArrayList<Student> slist = new ArrayList<>();
slist.add(new Student("小明","男"));
slist.add(new Student("小红",""));
Student s1 = new Student("小红", "女");
boolean contains = slist.contains(s1);
System.out.println(contains?"包含":"不包含");
}
}
6.双列集合
Map集合可以保存两列数据。
常见的Map集合:
HashMap 无序map集合
LinkedHashMap 有序map集合
Hashtable 线程安全的
ConcurrentHashMap 线程安全的
常见的Map方法
public static void main(String[] args) {
//格式：
//HashMap 变量名 = new HashMap<>();
//购物车：
HashMap<String, Integer> map = new HashMap<>();
//数据追加
map.put("苹果",1);
map.put("梨",2);
map.put("香蕉",1);
System.out.println(map);//{苹果=1, 香蕉=1, 梨=2}
//数据覆盖：Key已经存在，新值覆盖旧值
map.put("香蕉",10);
System.out.println(map);//{苹果=1, 香蕉=10, 梨=2}
System.out.println(map.size());//3
//如果键值对不存在的，get返回null
Integer v1 = map.get("香蕉");
System.out.println(v1);//10
Integer v2 = map.get("西瓜");
System.out.println(v2);//null
//判断键是否存在
System.out.println(map.containsKey("香蕉"));//true
System.out.println(map.containsKey("西瓜"));//false
//判断值是否存在
System.out.println(map.containsValue(10));//true
System.out.println(map.containsValue(100));//false
Integer value = map.remove("香蕉");
System.out.println(value);//10
Integer value2 = map.remove("香蕉");
System.out.println(value2);//null
System.out.println(map);//{苹果=1, 梨=2}
map.clear();
System.out.println(map);//{}
System.out.println(map.size());//0
System.out.println(map.isEmpty());//true
}
Map的常见操作
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("苹果",1);
map.put("梨",2);
map.put("香蕉",1);
//遍历操作
//map.keySet().for
for (String key : map.keySet()) {
System.out.println(key+" "+map.get(key));
}
//map.entrySet().for (建议)
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
和ArrayList一样，如果需要进行ContainsKey判断，自定义类型，需要写@EqualsAndHashCode
7.数组&集合常见操作
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a1","a2","a3","a4");
System.out.println(list);
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list1,55,44,99,11);
Collections.sort(list1,new Comparator<Integer>(){
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(list1);
}
8. 函数
函数定义
public 返回值类型 方法名(参数列表){
//方法体
return 返回值;
}
public static 返回值类型 方法名(参数列表){
//方法体
return 返回值;
}
public class Demo1 {
public int run1(){
return 10;
}
public void run2(){
//无需进行return
}
public static void run3(){
//无需进行return
}
public static void main(String[] args) {
Demo1 d1 = new Demo1();
d1.run1();
d1.run2();
run3();
}
}
函数调用
public class Demo2 {
public void run1(int a,String b){
}
public static void main(String[] args) {
Demo2 d2 = new Demo2();
d2.run1(10,"a1");
}
}
函数注意
static与非static 一般书写非static方法。 创建对象（Spring创建）