java基础总结1
数据类型：
1. 数据类型={整形{1字节byte、2字节short、4字节int、8字节long}、字符类型{2字节char}、浮点型{4字节float、8字节double}、布尔类型boolean}；
分别对应{Byte/Short/Integer/Long/Character/Float/Double/Boolean}
String str="123";
int inte=Integer.parseInt(str);//一种装换方式
int inte2=new Integer(str);//two way
数值的表示可以用二八十十六进制的来表示，他们之间可以使用下划线来连接
int int1=0b1010;//整数的写法--binary,int1=0b10_10;
int int2=012; //整数的写法--octonary
int int3=0xa; //整数的写法--hexadecimal`
char char1='你';//采用16位的unicode来表示全世界的语言
String str="if you can doeverything,tell me";
double doubl=5.1e2;//this a 510.0
类和对象
1. static修饰的东西属于类，不属于对象
2. 方法的引用必须有类或者对象为前提，少了有隐性的this
3. 参数的调用(可变参数和固定参数)
public void run1(intx,String...book)
{
for(Stringstr:book)
{
System.out.println(str);
}
}
public void run2(intx,String book[])
{
for(Stringstr:book)
{
System.out.println(str);
}
}
public static void main(String[] args)
{
date_type da=new date_type();
da.run1(2,"hello","every","one");
da.run2(1,new String []{"hello","every", "one"});
}
4. this和super的使用，重构，封装，多态
5. 运行时候产生的数据是放在内存区（堆内存），并不是放在常量池
6. Java类包含5种成员：成员变量、方法、构造函数器、初始化块、内部类
class date//创建单个对象的类的实例
{
private int age;
private static date instance;
private date(){}//隐去构造函数
public static date getinstance()
{
if(instance==null)
{
instance=new date();
}
returninstance;
}
}
public class date_type
{
public static void main(String [] args)
{
date p1=date.getinstance();
date p2=date.getinstance();
System.out.println(p1==p2);
}
}
}
7. Fianl的成员变量的初始化不能在普通成员方法里面进行，函数里面就只有构造器里面可以初始化。如果定义的是局部变量，那就在局部变量的范围里面赋值。Final的意思也就是终态不可以被改变。
8. 抽象类只要里面存在抽象的方法，其余和正常类没区别
abstract class date//
{
private final int age=3;
private static date instance;
public abstract void perimeter();
private void run()
{
}
}
public class
date_type extends date
{
public void perimeter()
{
}
public static void main(String [] args)
{
System.out.println("hello");
}
}
}
9. 内部类的使用：内部内就相当于一个在类内部定义的成员变量，他可以使用外部类的所有资源，比如外部类的数据，定义。但是外部类不能直接访问非静态的内部类的实例变量，只有创建了内部类的对象，通过对象引用。（内部类的存在依赖外部类，所以当有内部类时，可以直接引用外部类的东西）
静态的东西不能访问非静态的
非静态内部类不能含有静态的变量
package www.zylg.com;
public class innerclass//内部类的调用,在内部类调用外部的变量
{
private Stringstr="i am out variate";
private class inclass
{
private Stringstr="my name is innervariate";
public void info()
{
String str="my name is local variable";
System.out.println(innerclass.this.str);
System.out.println(this.str);
System.out.println(str);
}
}
private static class staticinnerclass
{
private static int age=6;
private Stringname="world";
}
public void test()
{
new inclass().info();
System.out.println(staticinnerclass.age); //静态内部类的调用
System.out.println(new staticinnerclass().name);
}
public static void main(String[] args)
{
new innerclass().test();
new innerclass().new inclass().info();//非静态内部类的调用
System.out.println(new innerclass.staticinnerclass().name);//静态内部类的调用
}
}
10. 局部内部类，在一个方法里定义的类，只是在这个方法的有效范围使用，所以没有修饰控制符和静态的声明
11. 匿名内部类，只是使用一次的类，但是需要继承接口或者类才行.
12. 枚举类，可以valueof(classname.class,“enum variate”)返回枚举类型，可以赋值枚举的变量和操作。Values（）返回全部的枚举
package www.zylg.com;
enum season//定义枚举类
{
spring,summer,fall,winter;
public Stringname;
public void printer()
{
System.out.println(name);
}
}
public class innerclass
{
public void seasonjudge(season s)//找到相应的枚举，并为枚举的变量赋值
{
switch(s)
{
case spring:{seasona=season.valueOf(season.class,"spring");a.name="春天";a.printer();break;}
case summer:{seasona=season.valueOf(season.class,"summer");a.name="夏天";a.printer();break;}
case fall:{seasona=season.valueOf(season.class,"fall");a.name="秋天";a.printer();break;}
case winter:{seasona=season.valueOf(season.class,"winter");a.name="冬天";a.printer();break;}
}
}
public static void main(String[] args)
{
for(seasons:season.values())//直接获取全部的枚举
{
new innerclass().seasonjudge(s);
}
}
}
13. 一个对象在堆内存之中运行，有三种状态可达、可恢复、不可达，只有在对象被销毁时才进入可恢复状态，强制回收System.gc()和Runtime.getRuntime().gc();
14. 对象的强strongreference、软softreference、弱weakreference和虚phantomreference引用
package www.zylg.com;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
public class innerclass
{
public static void main(String[] args)
{
String str1=new String("hello zylg");
WeakReference wr=new WeakReference(str1);//weak reference
str1=null;//取出弱引用的对象
System.out.println(wr.get());
System.gc();//强制回收
System.runFinalization();//强制回收
System.out.println(wr.get());
String str2=new String("hello world");
SoftReference wr2=new SoftReference(str2);//软引用
str2=null;//取出弱引用的对象
System.out.println(wr2.get());
System.gc();//强制回收
System.runFinalization();//强制回收
System.out.println(wr2.get());
}
}
基础类库
1. scanner获取键盘输入new Scanner(System.io)
package www.zylg.com;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class innerclass
{
static Filefl=new File("J:\\java\\day\\hellp\\src\\www\\zylg\\com\\1.txt");
public static void main(String[] args) throws FileNotFoundException
{
Scanner sc=new Scanner(fl);
while(sc.hasNextLine())//has*判断是否存在
{
System.out.println(sc.nextLine());
}
}
}
2. system
package www.zylg.com;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
public class innerclass
{
public static void main(String[] args) throws IOException
{
Map<String,String> env=System.getenv();//获取所有环境变量的值
for(Stringname:env.keySet())
{
// System.out.println(name+"----->"+env.get(name));
}
//获取单个环境变量的值
System.out.println(System.getenv("java_home"));
//获取所有的系统属性
Properties pro=System.getProperties();
// pro.store(newFileOutputStream("F:\\临时文件夹1\\pro.txt"), "系统属性");
for(Objectstr1:pro.keySet())
{
System.out.println(str1+"----->"+ System.getProperty(str1.toString()));
}
}
}
3. runtime类
package www.zylg.com;
import java.io.IOException;
import java.util.Scanner;
public class innerclass
{
public static void main(String[] args) throws IOException
{
Runtime rt=Runtime.getRuntime();//将运行的进程和runtime类相关联
System.out.println("freemomery="+rt.freeMemory());
System.out.println("totalmemory="+rt.totalMemory());
System.out.println("maxmemory"+rt.maxMemory()/1000000);
System.out.println(rt.availableProcessors());//处理器数量
Scanner sc=new Scanner(System.in);
String str;
while(true)
{
str=sc.next();
if(str.equals("exit"))break;
rt.exec(str);
}
}
}
4. object是所有类的父类
5. string被创建以后字符序列是不可以变得、stringbuffer看可以使用append等改变、stringbuilder不和stringbuffer一样具有安全性
6. math函数
7. random随机数
8. 高精度的浮点数计算类bigdecimal
9. 时间和日期,在time包里面特别多
package www.zylg.com;
import java.util.Calendar;
import java.util.Date;
public class innerclass
{
public static void main(String[] args)
{
Date d1=new Date();
System.out.println(d1);
Calendar cal=Calendar.getInstance();
Date d2=cal.getTime();
System.out.println(d2);
cal.set(2022, 9, 30, 23, 30, 31);
cal.set(Calendar.YEAR, 2019);
cal.add(Calendar.MONTH, -2);
cal.roll(Calendar.DATE, -10);
System.out.println(cal.get(Calendar.YEAR)+"年"+cal.get(Calendar.MONTH)+"月"+cal.get(Calendar.DATE)
+"日 "+cal.get(Calendar.HOUR)+":"+cal.get(Calendar.MINUTE)+":"+cal.get(Calendar.SECOND));
}
}
10. 正则表达式
package www.zylg.com;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class innerclass
{
public static void main(String[] args)
{
String str[]={"13289762351","13289897655","16709876543","1321234567890"};
System.out.println("查找132开头的电话号码：");
Pattern p=Pattern.compile("132\\d{8}$");
Matcher m=null;
for(Stringst:str)
{
m=p.matcher(st);
if(m.find())
{
System.out.println(m.group());
}
}
}
}
Java集合
1.集合概述
package www.zylg.com;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class innerclass
{
public static void main(String[] args)
{
Collection c1=newArrayList(); //add() remove() removeall() size
c1.add("专业路过");c1.add("你好");c1.add("6");
c1.remove("6");
System.out.println("集合的大小"+c1.size()+"\t"+c1);
Collection c2=newHashSet(); //addall()
c2.addAll(c1);c2.add("大家好");
c2.forEach(obj->System.out.println(obj));
c2.retainAll(c1); //让c2只是包含c1的数据
Iterator it=c2.iterator();
while(it.hasNext()){System.out.println(it.next());}
}
}
Linkedhashset添加和输出的元素顺序一致
Treeset
package www.zylg.com;
import java.util.TreeSet;
public class innerclass
{
public static void main(String[] args) //int float double longstream操作数据
{
TreeSet nums=newTreeSet();//两个对象必须那能够作比较，不然会抛出异常
nums.add(1);
nums.add(2);
nums.add(3);
nums.add(4);
nums.add(5);
nums.add(6);
nums.add(7);
nums.add(7);
System.out.println(nums.first());//第一个元素
System.out.println(nums.last());//最后一个元素
System.out.println(nums.headSet(3));//小于3的元素
System.out.println(nums.tailSet(6));//不小于6的元素
System.out.println(nums.subSet(3, 5));//大于或等于3小于5的元素
}
}
Enumset
package www.zylg.com;
import java.util.EnumSet;
public class innerclass
{
enum season
{
spring,summer,fall,winter;
}
public static void main(String[] args)
{
EnumSet es1=EnumSet.allOf(season.class);//专门为枚举的集合
es1.add(season.winter);
EnumSet es2=EnumSet.copyOf(es1);
System.out.println(es1);
System.out.println(es2);
}
}
List集合是有序可以重复的集合
package www.zylg.com;
import java.util.ArrayList;
public class innerclass
{
public static void main(String[] args) //list are order and repetition
{
ArrayList li1=newArrayList();//vector is like arraylist
li1.add("有些话");
li1.add("不说");
li1.add("也知道");
li1.add("吗？");
li1.remove(0);
System.out.println(li1.get(1));
System.out.println(li1.subList(1, 3));
}
}
Queue队列集合“先进先出”
Hashmap
package www.zylg.com;
import java.util.HashMap;
import java.util.Map;
public class innerclass
{
public static void main(String[] args) //key is only
{
Map m=newHashMap();
m.put("language", 80);
m.put("math",99);
m.put("english", 70);
m.put("english", 80);//it is will replaceenglishvalue
System.out.println(m);
for(Objectstr:m.keySet())
{
System.out.println(str+":"+m.get(str));
}
}
}
此外，linkedhashmap具有顺序性，treemap和sortedmap用于比较（不知道）， identityhashmap必须key和key相等才算相等
Collection工具
排序
Void reverse(List list)//反转list集合中元素的顺序
Void shuffle(List list)//随机排序
Void sort(List list)//对集合进行升序排序
Void sort(List list,Comparator c)//根据c进行排序
Void swap(List list,int I,int j)
Void rotate(List list,distace d)//移动d的元素
查找、替换
Int binarysearch(List list,Object key)//二分法查找，必须保证list有序
Object max(collection coll)返回最大元素
Object min(Collection colll)返回最小元素
Void fill(List list,Object obj)让obj替换list的所有元素
Int frequency(Collection c,Object o)返回集合中指定元素出现的次数
Boolean replaceall(List list,Object old,Objectnew)用新值替换旧值
同步控制
Collections.synchronizedCollection(newArrayList<>());
泛型
packagecom.zylg.www;
importjava.util.ArrayList;
importjava.util.Collection;
public class find
{
static <T>void fromarraytocollection(T[] a,Collection<T>c)//声明泛型
{
for(T o:a)
{
c.add(o);
}
}
public static void main(String[] args)
{
Object[] oa=new Object[100];
Collection<Object> co=new ArrayList<>();
fromarraytocollection(oa,co);
String[] str=new String[10];
Collection<String> co2=new ArrayList<>();
fromarraytocollection(str,co2);
}
}
异常处理，try里面可以添加throw抛出，finally始终会执行，可以嵌套
Try{}
Catch{}
Finally{}
浙公网安备 33010602011771号