一、易忘易错基础知识
1、常量、变量
1）成员变量：在类体重定义的变量，在整个类中有效，分为静态变量和实例变量。
2）局部变量：只在当前代码块中有效。
//常量
char char1='b';//声明char类型的**变量**
final double PI=3.1415926F;//声明double类型**常量**并赋值
//变量
class var{
int x=45;//定义实例变量
static int y=90;//静态变量
}
2、循环终止
break:终端整个循环；
continue：放弃本次循环的剩余代码，而开始下一轮的循环。
3、数组
1）二维数组分配内存：
a=new int[2][4];//为每一维分配相同的内存
a=new int[2][];
a[0]=new int[2];
a[1]=new int[3];//分别为每一维单独分配内存
3）二维数组遍历
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
//使用foreach
for(int x[]:a){//外层循环变量为一维数组
for(int e:x){//循环遍历每一个数组元素
System.out.print(e+" ");
}
System.out.println();
}
4）填充替换数组元素（Arrays.fill())
int a[]=new int[]{45,12,2,10,1};
Arrays.fill(a,1,3,8);
//四个参数分别是数组名，使用指定值填充的第一个元素的索引（包括）；最后一个索引（不包括）；要存储数组所有元素的值
//输出结果：45，8，8，10，1
5）排序（Arrays.sort())
6)复制（Arrays.copyOf()、copyOfRange())
int newA=Arrays.copyOf(a,5);
//参数分别为要复制的数组，复制后新数组的长度，若大于原数组，则用0（int）或 null（char）填充
int newA=Arrays.copyOfRange(a,0,3);
//将数组下标0~3（不包括3）复制
4、字符串
1）创建字符串
1：
String s=new String();
2:利用字符数组
char a[]={'g','o','o','d'};
String s=new String(a);
//等价于String s=new String(“good”);
3:
String s=new String(a,1,3);//第三个参数是**length**
//等价于String s=new String(“ood”);
2）字符串长度
s.length()
3)指定字符的索引位置
s.indexOf("s");//s是要搜索的字符，返回**第一次**出现的索引
s.lastIndexOf("s");//返回序列中**最后**出现的该字符的索引
4）获取制定索引位置的字符
s.charAt(6);//返回字符串中索引位置是6的字符
5）去除字符串空格
去掉前导和尾部的空格
String s2=s1.trim();
去掉所有空格,以下两种方法
StringTokenizer(String str,String delim)，参数分别为要处理的字符串，从字符串s中去除的字符串
StringTokenizer st=new StringTokensizer(s," ");
str.replaceAll(String regex,String replace)
str:要处理的字符串；regex：要被替换的字符串；replace：用来替换的新字符串
s=s.replaceAll(" ","");//参数分别为
6）字符串替换
s.replace(String a,String b);
s.replaceFirst(String a,String b);
7)判断字符串(boolean 型）
1、是否相等
str.equals(String otherstr);
str.equalsIgnoreCase(String otherstr);//忽略大小写
2、判断开始和结尾
str.startsWith(String a);
str.endsWith(String b);
8）大小写转换
str.toLowerCase();
str.toUpperCase();
9)字符串分割
str.split(String a);//根据指定分割符进行完全分割
String[] news=s.split(",");
str.split(String a,int limit);//指定分隔符并限制分割份数
String[] news=s.split(",",2);
5、字符串生成器StringBuilder类
1）说明：
1、StringBuilder与String相比，对字符串做更新操作时所用的时间大大减少
StringBuilder是一个可变的字符序列，是StringBuffer类的简易替换，在字符串被耽搁线程使用是要比2、AtringBuffer类快。但是StringBuilder将的实例用于多个线程是不安全的，这时就要使用StringBuffer类来实现。
2）常用方法
1、将指定字符串追加到字符串生成器中
String s="good";
StringBulider builder=new StringBuilder();//构造字符串生成器
builder.append(s);//将s的值追加到字符串生成器中
System.out.println("追加后builder的值"+builder);
2、将指定字符串缓存追加到字符串生成器中
StringBuffer buffer=new StringBuffer("sunday");//创建初始内容为Sunday的字符串缓存
StringBulider builder=new StringBuilder();//构造字符串生成器
builder.append(s);//将s的值追加到字符串生成器中
System.out.println("追加后builder的值"+builder);
3、将指定字符串添加加到offset指定位置
builder.insert(int offset,String str);
String s1="hhh";
String s2="nnn";
StringBulider builder=new StringBuilder(s1);//**构造初始值为hhh的字符串生成器**
builder.insert(2，s2);//向索引2处添加字符串nnn
4、移除start——end之间的字符串生成器中的子字符串
builder.delete(int start,int end);
5、返回字符串生成器的字符串表示
str.toString();
StringBulider builder=new StringBuilder();
String s=builder.tostring();
6、一些关键字
一、this:隐式地用于引用对象的成语变量和方法。
二、Static关键字: 只能用于修饰成员变量和成员方法。
Static修饰的成员变量就成了类变量，随着类的加载而加载，生命周期和类一样。
Static修饰的成员方法变成了类方法，可以直接通过类名调用。和.class一样存在于方法区。
非静态的成员方法与成员变量的调用，只能通过创建对象调用**(new)**。类名.方法名等；而静态的成员可以通过类名和创建对象调用（尽量用类名调用，不要创建对象）。
被修饰的成员有以下特点:
1）随着类的加载而加载、
2）优先于对象存在、
3）被所有对象所共享(比较节约空间)、（可以用代码证明）
4）可以直接被类名调用， Constant.BASE_URL、NetManager.getData();
注意事项:
1）静态方法只能访问静态的成员变量，不能访问非静态的成员变量。 为什么？因为静态成员先于对象存在，比对象先创建。当静态成员存在时，对象还没有创建。他们的生命周期不一样。但是非静态的可以访问静态的。
2）静态方法中不可用this/super关键字。为什么：this指向调用本方法的对象的引用（对象还没有创建呢）
静态成员与非静态成员的区别：
生命周期:
静态成员随着类的加载而加载，随着类的消失而消失，生命周期长；
普通成员随着对象的存在而存在，随着对象的消失而消失。
存放位置:静态成员存在于方法区中，非静态成员存在于堆中。
三、final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。
1、修饰类: 当用final修饰一个类时，表明这个类是最终类，不能被继承。如果一个类你不想让它被继承，就可以用final进行修饰。
2、修饰方法：使用final修饰的方法不能被子类重写。(最终方法)
3、修饰变量: 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
由final修饰的变量，是常量，一旦初始化后，它的值不能被修改，即不能被重新赋值，主要是项目中应用的常量的抽取：比如URL常量、路径常量、数字常量等.不能让人轻易修改。
注意: 当final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
7、内部类
Java内部类详解
Java静态内部类
几点小总结：
1、修饰为private的类成员可以在内部类中随意使用；
2、要声明静态成员时，使用静态内部类。创建静态内部类的对象，不需要外部类的对象。不呢个从静态内部类的对象中访问非静态外部类的对象。
3、使用this关键字获取内部类与外部类的引用：
poublic class Outer{
private int x;
private class inner{
private int x=9;
public void doit(int x){
x++;//调用的是形参x
this.x++;//调用内部类的变量x
Outer.this.x++;//条用外部类的变量x
}
}
}
二、集合类
1、辨析：
集合类（容器）长度是可变的，而数组的长度是固定的。集合用来存放对象的引用，数组用来存放基本类型的数据。
常用的集合有;List、Set、Map（其中List和Set提供collection接口）
2、List接口常用方法
void add(int index, Object element)
将元素elment插入在集合list的index处，其他对象的索引位置相对后移
Object set(int index, Object o)
将集合中index索引处的元素替换成o
boolean addAll(int index, Collection c)
将集合c中的元素插入到集合List的index处
Object get(int index)
返回List集合index索引处的元素
Object remove(int index)
移除List集合index索引处的元素
Int indexOf(Object o)
返回集合中元素o的index索引
int lastIndexOf(Object o)
返回集合中最后一个元素的索引
List subList(int fromIndex,int toIndex)
返回集合中从索引fromIndex到toIndex索引处的元素集合
//创建集合对象，并向集合中添加元素，通过set()方法修改集合中元素，再通过add()方法向集合中添加元素，通过迭代器遍历集合元素。
public class Main
{
public static void main(String[] args) {
String a="A",b="B",c="C",d="D",e="E";
List list=new LinkedList(); //创建List集合
list.add(a);
list.add(e);
list.add(d);
Iterator firstIterator=list.iterator(); //创建集合中的迭代器
System.out.println("修改前集合中的元素是：");
while(firstIterator.hasNext()){ //遍历集合中的元素
System.out.println(firstIterator.next()+" ");
}
list.set(1, b); //将索引位置为1的对象修改为对象
b list.add(2,c); //将对象c添加到索引位置为2的位置
Iterator it=list.iterator(); //创建将集合对象修改后的迭代器对象
System.out.println();
System.out.println("修改后集合中的元素是:");
while(it.hasNext()){ //循环获取集合中元素
System.out.print(it.next()+" ");
}
}
}
3、Set接口常用方法
add(Object obj) boolean 如果此Set集合中尚未存在指定的元素，则添加此元素
addAll(Collection coll) boolean 将参数集合中所有元素添加到此Set集合的尾部
remove(Object obj) boolean 将指定的参数对象移除集合
removeAll(Collection c) boolean 在Set集合中移除包含在指定Collection中的元素
retainAll(Collection c) boolean 只保存Set集合中包含在指定Collection集合中的内容
clear() void 移除此Set中的所有元素
iterator() Iterator 返回此Set集合中的所有元素数
size() int 返回此Set集合中的所有元素数
isEmpty() boolean 如果Set不包含元素，则返回true
小技巧：由于Set集合中不允许存在重复值，因此可以使用Set集合中的addAll()方法，将Collection集合添加到Set集合中并除掉重复值。
//创建一个List集合对象，往list中添加元素。再创建一个Set集合，利用addAll()方法把List集合对象存入到Set集合中并去除重复值。
public clas Main(){
public static void main(String[] args){
List<String>list=new ArrayList<String>();//**创建List集合对象**
list.add("apple");
list.add("pear");
list.add("banana");
list.add("apple");
Set<String> set=new HashSet<String>();//**创建Set集合对象**
set.addAll(list); //将List对象添加到Set集合中
Iterator<String> it=set.iterator(); //**创建Set集合迭代器**
System.out.println("集合中的元素是：");
while(it.hasNext()){
System.out.print(it.next()+"\t");
}
}
}
4、Map接口常用方法
put(key k, value v) Object 向集合中添加指定的key与value的映射关系
containskey(Object key) boolean 如果此映射包含指定键的映射关系，则返回true
containsValue(Object value) boolean 如果此映射将一个或多个键映射到指定值，则返回true
get(Object key) Object 如果存在指定的键对象，则返回该对象对应的值，否则返回null
keySet() Set 返回该集合中的所有键对象组成的Set集合
values() Collection 返回该集合中所有值对象形成的Collection集合
public class Main(){
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>; //**创建Map集合**
map.put("1","apple"); //向集合中添加对象
map.put("2","pear");
map.put("3","orange");
for(int i=1;i<=3;i++){
System.out.println("第"+i+"元素是："+map.get(""+i+"")); //输出对应未知的元素值
}
}
}
5、Iterator迭代器
1）方法
1、hasNext():仍有元素可迭代，则返回true
2、next()：返回迭代的下一个元素
3、remove():从迭代器指向的collection中移除迭代器返回的最后一个元素
2）遍历ArrayList
public class Main
{
public static void main(String[] args) {
List<integer> list=new ArrayList<Integer>(); //创建列表
for(int i=0;i<10;i++){
list.add(i);
}
System.out.println("列表中的全部元素：");
for(Iterator<Integer> it=list.iterator();it.hasNext();){
System.out.print(it.next()+" ");
}
}
}
三、一些函数
1、进制转换
- System.out.println(Integer.toBinaryString(arg0));//十进制转换为二进制
- System.out.println(Integer.toOctalString(arg0));//十进制转换为八进制
- System.out.println(Integer.toHexString(arg0));//十进制转换为十六进制
- System.out.println(Integer.valueOf(“5”,8).toString());//八进制转换为十进制
- System.out.println(Integer.valueOf(“FFFF”,16).toString());//十六进制转换为十进制
- System.out.println(Integer.valueOf(“0101”,2).toString());//二进制转换为十进制
2、Java中字符，字符串，整数的转化
string 和int之间的转换
string转换成int :Integer.valueOf(“12”)
int转换成string :String.valueOf(12)
char和int之间的转换
首先将char转换成string
Stringstr=String.valueOf(‘2’)
Integer.valueof(str)或者Integer.PaseInt(str)
Integer.valueof返回的是Integer对象，Integer.paseInt返回的是int
3、Java的运算符-取整，取绝对值，取余数
-
舍掉小数取整:Math.floor(3.5)=3
-
四舍五入取整:Math.rint(3.5)=4
-
进位取整:Math.ceil(3.1)=4
-
取绝对值：Math.abs(-3.5)=3.5
-
取余数：A%B = 余数
4、toUpperCase()与toLowerCase()大小写转换函数
5、subString()截取函数
subString(0,n) 前闭后开，即包含0，不包含n
6、replace(), replaceFirst(), replaceAll()替换函数
replace()是全局替换，只支付匹配字符串替换，不支持正则表达式；
replaceFirst()，既支持字符串替换，也支持正则表达式替换，但只替换第一次出现的字符串；
replaceAll()，既支持字符串替换，了支持正则表达式替换，是全局替换。
7、数组排序
Arrays.sort(arr);
8、reverse反转函数
StringBuffer buffer = new StringBuffer(“Hello World.”);
buffer.reverse();
9、去掉字符串的前后空格
String s = " test ";
s = s.trim();
10、返回数组某索引下的值
char numH=h.charAt(m);
返回的是某个索引下的char值。比如h为“abcde”。那么h.charAt(0)返回的就是索引0对应的值，为a
11、求长度
1 数组长度：length
2 针对字符串String，求长度：length()方法
3.针对泛型集合：size()方法
11、List逆序、倒叙、随机排序
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Test {
List list = new LinkedList();
public static void main(String[] args) {
List list = new LinkedList();
for ( int i = 0 ; i < 9 ; i ++ ) {
list.add( " a " + i);
}
Collections.sort(list); // 顺序排列
System.out.println(list);
Collections.shuffle(list); // 混乱的意思
System.out.println(list);
Collections.reverse(list); // 倒序排列
System.out.println(list);
System.out.println(Collections.binarySearch(list, " a5 " )); // 折半查找
}
}
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
