Welcome to My Blog!

这里记录着我的java后端学习之路

java基础复习八Java集合

2019-03-10

百味皆苦

java基础

java基础集合

ArrayList
- 区别数组
  - 数组局限
  - 存放对象
- 常用方法
  - 增加
  - 判断
  - 获取
  - 位置
  - 删除
  - 替换
  - 大小
  - 变数组
  - 加所有
  - 清空
- List接口
  - API
- 泛型
- 遍历
  - for
  - 迭代器

ArrayList

区别数组

数组局限

如果要存放多个对象，可以使用数组，但是数组有局限性
比如声明长度是10的数组，不用的数组就浪费了，超过10的个数，又放不下

package collection;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		//数组的局限性
		Hero heros[] = new Hero[10];
		//声明长度是10的数组
		//不用的数组就浪费了
		//超过10的个数，又放不下
		heros[0] = new Hero("盖伦");
                //放不下要报错
		heros[20] = new Hero("提莫");
		
	}
	
}

存放对象

为了解决数组的局限性，引入容器类的概念。最常见的容器类就是 ArrayList
容器的容量“capacity”会随着对象的增加，自动增长
只需要不断往容器里增加英雄即可，不用担心会出现数组的边界问题

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) {
		//容器类ArrayList，用于存放对象
		ArrayList heros = new ArrayList();
		heros.add( new Hero("盖伦"));
		System.out.println(heros.size());
		
		//容器的容量"capacity"会随着对象的增加，自动增长
		//只需要不断往容器里增加英雄即可，不用担心会出现数组的边界问题。
		heros.add( new Hero("提莫"));
		System.out.println(heros.size());
		
	}
	
}

常用方法

增加

add 有两种用法
第一种是直接add对象，把对象加在最后面heros.add(new Hero("hero " + i));
第二种是在指定位置加对象heros.add(3, specialHero);

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 把5个对象加入到ArrayList中
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		System.out.println(heros);

		// 在指定位置增加对象
		Hero specialHero = new Hero("special hero");
		heros.add(3, specialHero);

		System.out.println(heros.toString());

	}

}

判断

通过方法contains 判断一个对象是否在容器中
判断标准：是否是同一个对象，而不是name是否相同

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);

		System.out.println(heros);
		// 判断一个对象是否在容器中
		// 判断标准： 是否是同一个对象，比较的是内存地址，而不是name是否相同
		System.out.print("虽然一个新的对象名字也叫 hero 1，但是contains的返回是:");
		System.out.println(heros.contains(new Hero("hero 1")));
		System.out.print("而对specialHero的判断，contains的返回是:");
		System.out.println(heros.contains(specialHero));
	}

}

获取

通过get获取指定位置的对象（从0开始），如果输入的下标越界，一样会报错

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		//获取指定位置的对象
		System.out.println(heros.get(5));
		//如果超出了范围，依然会报错
		System.out.println(heros.get(6));

	}

}

位置

indexOf用于判断一个对象在ArrayList中所处的位置
与contains一样，判断标准是对象是否相同，而非对象的name值是否相等

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);

		System.out.println(heros);
		System.out.println("specialHero所处的位置:"+heros.indexOf(specialHero));
		System.out.println("新的英雄，但是名字是\"hero 1\"所处的位置:"+heros.indexOf(new Hero("hero 1")));

	}
}

删除

remove用于把对象从ArrayList中删除
remove可以根据下标删除ArrayList的元素heros.remove(2);
也可以根据对象删除,heros.remove(specialHero);

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		System.out.println(heros);
		heros.remove(2);
		System.out.println("删除下标是2的对象");
		System.out.println(heros);
		System.out.println("删除special hero");
		heros.remove(specialHero);
		System.out.println(heros);
		
	}
}

替换

set用于替换指定位置的元素

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		System.out.println(heros);
		System.out.println("把下标是5的元素，替换为\"hero 5\"");
		heros.set(5, new Hero("hero 5"));
		System.out.println(heros);
	}
}

大小

size 用于获取ArrayList的大小

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		System.out.println(heros);
		System.out.println("获取ArrayList的大小：");
		System.out.println(heros.size());
	}
}

变数组

toArray可以把一个ArrayList对象转换为数组。
需要注意的是，该方法是一个泛型方法：<T> T[] toArray(T[] a); 如果toArray方法中没有传递任何参数的话返回的是Object类型数组。

String [] s= new String[]{
    "dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A"
};
List<String> list = Arrays.asList(s);
Collections.reverse(list);
s=list.toArray(new String[0]);//没有指定类型的话会报错

/*
由于JVM优化，new String[0]作为Collection.toArray()方法的参数现在使用更好，new String[0]就是起一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为它只是为了说明返回的类型。
*/

加所有

addAll 把另一个容器所有对象都加进来

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}

		System.out.println("ArrayList heros:\t" + heros);
		 
		//把另一个容器里所有的元素，都加入到该容器里来
		ArrayList anotherHeros = new ArrayList();
		anotherHeros.add(new Hero("hero a"));
		anotherHeros.add(new Hero("hero b"));
		anotherHeros.add(new Hero("hero c"));
		System.out.println("anotherHeros heros:\t" + anotherHeros);
		heros.addAll(anotherHeros);
		System.out.println("把另一个ArrayList的元素都加入到当前ArrayList:");
		System.out.println("ArrayList heros:\t" + heros);
		
	}
}

清空

clear 清空一个ArrayList

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}

		System.out.println("ArrayList heros:\t" + heros);
		System.out.println("使用clear清空");
		heros.clear();
		System.out.println("ArrayList heros:\t" + heros);
		 
	}
}

List接口

ArrayList实现了接口List
常见的写法会把引用声明为接口List类型
注意：是java.util.List,而不是java.awt.List

package collection;
 
import java.util.ArrayList;
import java.util.List;

import charactor.Hero;
 
public class TestCollection {

    public static void main(String[] args) {
    	//ArrayList实现了接口List
    	
    	//常见的写法会把引用声明为接口List类型
    	//注意：是java.util.List,而不是java.awt.List
    	//接口引用指向子类对象（多态）
    	
        List heros = new ArrayList();
        heros.add( new Hero("盖伦"));
        System.out.println(heros.size());
        
    }
     
}

API

"方法摘要 "
 void add(String item) 
         " 向滚动列表的末尾添加指定的项。 "
 void add(String item, int index) 
         " 向滚动列表中索引指示的位置添加指定的项。 "
 void addActionListener(ActionListener l) 
          "添加指定的动作侦听器以从此列表接收动作事件。 "
 void addItemListener(ItemListener l) 
          "添加指定的项侦听器以接收此列表的项事件。" 
 void addNotify() 
          "创建列表的同位体。"  
 void deselect(int index) 
         " 取消选择指定索引处的项。 "
 AccessibleContext getAccessibleContext() 
         " 获取与此 List 关联的 AccessibleContext。" 
 ActionListener[] getActionListeners() 
         " 返回已在此列表上注册的所有动作侦听器的数组。" 
 String getItem(int index) 
         " 获取与指定索引关联的项。" 
 int getItemCount() 
          "获取列表中的项数。 "
 ItemListener[] getItemListeners() 
         " 返回已在此列表上注册的所有项侦听器的数组。" 
 String[] getItems() 
          "获取列表中的项。" 
<T extends EventListener> T[] 
 getListeners(Class<T> listenerType) 
          "返回目前已在此 List 上注册为 FooListener 的所有对象的数组。 "
 Dimension getMinimumSize() 
          "确定此滚动列表的最小大小。" 
 Dimension getMinimumSize(int rows) 
         " 获取具有指定行数的列表的最少维数。" 
 Dimension getPreferredSize() 
          "获取此滚动列表的首选大小。" 
 Dimension getPreferredSize(int rows) 
         " 获取具有指定行数的列表的首选维数。 "
 int getRows() 
         " 获取此列表中的可视行数。 "
 int getSelectedIndex() 
         " 获取列表中选中项的索引。" 
 int[] getSelectedIndexes() 
         " 获取列表中选中的索引。" 
 String getSelectedItem() 
         " 获取此滚动列表中选中的项。 "
 String[] getSelectedItems() 
         " 获取此滚动列表中选中的项。" 
 Object[] getSelectedObjects() 
        "  获取对象数组中此滚动列表的选中项。 "
 int getVisibleIndex() 
         " 获取上次由 makeVisible 方法使其可视的项的索引。 "
 boolean isIndexSelected(int index) 
         " 确定是否已选中此滚动列表中的指定项。" 
 boolean isMultipleMode() 
          "确定此列表是否允许进行多项选择。"  
 void makeVisible(int index) 
         " 使指定索引处的项可视。" 
protected  String paramString() 
          "返回表示此滚动列表状态的参数字符串。"  
protected  void processActionEvent(ActionEvent e) 
         " 处理发生在此列表上的动作事件，方法是将这些事件指派给所有已注册的 ActionListener 对象。" 
protected  void processEvent(AWTEvent e) 
         " 此滚动列表的进程事件。" 
protected  void processItemEvent(ItemEvent e) 
          "处理发生在此列表上的项事件，方法是将这些事件指派给所有已注册的 ItemListener 对象。" 
 void remove(int position) 
          "从此滚动列表中移除指定位置处的项。" 
 void remove(String item) 
          "从列表中移除项的第一次出现。" 
 void removeActionListener(ActionListener l) 
          "移除指定的动作侦听器，以便不再从此列表接收动作事件。" 
 void removeAll() 
         " 从此列表中移除所有项。 "
 void removeItemListener(ItemListener l) 
         " 移除指定的项侦听器，以便不再从此列表接收项事件。 "
 void removeNotify() 
          "移除此列表的同位体。" 
 void replaceItem(String newValue, int index) 
         " 使用新字符串替换滚动列表中指定索引处的项。 "
 void select(int index) 
         " 选择滚动列表中指定索引处的项。" 
 void setMultipleMode(boolean b) 
         " 设置确定此列表是否允许进行多项选择的标志。" 

泛型

不指定泛型的容器，可以存放任何类型的元素
指定了泛型的容器，只能存放指定类型的元素以及其子类

package property;

public class Item {
	String name;
	int price;
	
	public Item(){
		
	}
	
	//提供一个初始化name的构造方法
	public Item(String name){
		this.name = name;
	}
	
	public void effect(){
		System.out.println("物品使用后，可以有效果");
	}
	
}

package collection;
  
import java.util.ArrayList;
import java.util.List;
 
import property.Item;
import charactor.APHero;
import charactor.Hero;
  
public class TestCollection {
 
    public static void main(String[] args) {
         
        //对于不使用泛型的容器，可以往里面放英雄，也可以往里面放物品
        List heros = new ArrayList();
         
        heros.add(new Hero("盖伦"));
         
        //本来用于存放英雄的容器，现在也可以存放物品了
        heros.add(new Item("冰杖"));
         
        //对象转型会出现问题
        Hero h1=  (Hero) heros.get(0);
        //尤其是在容器里放的对象太多的时候，就记不清楚哪个位置放的是哪种类型的对象了
        Hero h2=  (Hero) heros.get(1);
         
        //引入泛型Generic
        //声明容器的时候，就指定了这种容器，只能放Hero，放其他的就会出错
        List<Hero> genericheros = new ArrayList<Hero>();
        genericheros.add(new Hero("盖伦"));
        //如果不是Hero类型，根本就放不进去
        //genericheros.add(new Item("冰杖"));
         
        //除此之外，还能存放Hero的子类
        genericheros.add(new APHero());
        
        //并且在取出数据的时候，不需要再进行转型了，因为里面肯定是放的Hero或者其子类
        Hero h = genericheros.get(0);
        
    }
      
}

遍历

for

通过前面的学习，知道了可以用size()和get()分别得到大小，和获取指定位置的元素，结合for循环就可以遍历出ArrayList的内容

package collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import charactor.Hero;

public class TestCollection {

	public static void main(String[] args) {
		List<Hero> heros = new ArrayList<Hero>();

		// 放5个Hero进入容器
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero name " + i));
		}

		// 第一种遍历 for循环
		System.out.println("--------for 循环-------");
		for (int i = 0; i < heros.size(); i++) {
			Hero h = heros.get(i);
			System.out.println(h);
		}

	}

}

迭代器

使用迭代器Iterator遍历集合中的元素

package collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import charactor.Hero;
 
public class TestCollection {

    public static void main(String[] args) {
    	List<Hero> heros = new ArrayList<Hero>();
    	
    	//放5个Hero进入容器
    	for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero name " +i));
		}
    	
    	//第二种遍历，使用迭代器
    	System.out.println("--------使用while的iterator-------");
    	Iterator<Hero> it= heros.iterator();
    	//从最开始的位置判断"下一个"位置是否有数据
    	//如果有就通过next取出来，并且把指针向下移动
    	//直到"下一个"位置没有数据
    	while(it.hasNext()){
    		Hero h = it.next();
    		System.out.println(h);
    	}
    	//迭代器的for写法
    	System.out.println("--------使用for的iterator-------");
    	for (Iterator<Hero> iterator = heros.iterator(); iterator.hasNext();) {
			Hero hero = (Hero) iterator.next();
			System.out.println(hero);
		}
    	
    }
     
}

迭代器的注意点：用for循环遍历集合，对集合中满足条件的元素进行remove操作报错：ConcurrentModificationException，所以，在遍历集合进行增、删操作时，要使用迭代器的方式

package list;
 
import java.util.*;
 
public class Demo {
 
    public static void main(String[] args) {
        List<Object> obj = new ArrayList<Object>();
        obj.add("a");
        obj.add("b");
        obj.add("c");
        System.out.println("移除前：" + obj.toString());
        Iterator<Object> it = obj.iterator();
        for(int i=0; i<obj.size(); i++){
            System.out.println(i);
            Object name = it.next();
            if("a".equals(name) || "b".equals(name)){
                it.remove();
                i--;
            }
        }
        System.out.println("移除后： " + obj.toString());
         
    }
 
}

package set;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class Demo {
 
    public static void main(String[] args) {
        Set<Object> obj = new HashSet<Object>();
        obj.add("a");
        obj.add("b");
        obj.add("c");
        System.out.println("移除前：" + obj.toString());
        Iterator<Object> it = obj.iterator();
        for(int i=0; i<obj.size(); i++){
            System.out.println(i);
            Object name = it.next();
            if("a".equals(name) || "b".equals(name)){
                it.remove();
                i--;
            }
        }
        System.out.println("移除后： " + obj.toString());
         
    }
 
}

Read All

java基础复习-Java介绍

2019-03-02

百味皆苦

java基础

java基础 Java介绍
- 1：Java语言的主要特性
- 2：Java语言的核心内容
1：Java语言的主要特性

1简单性

Java语言是c++语言的一个“纯净”版本，这里没有头文件，指针运算（甚至指针语法）,结构，联合，操作符重载，虚基类等。

简单的另一个方面是小，Java的目标之一是支持开发能够在小型机器上独立运行的软件。

2面向对象

简单的讲，面向对象设计是一种程序设计技术，他将重点放在数据（即对象）和对象的接口上。

打个比喻：我（具有操作门的功能）去操作门（门有打开和关闭功能），把他打开，这就是面向对象

我走过去把门打开了，这是面向过程。

在本质上，Java的面向对象能力和c++是一样的，主要不同在于多继承（Java支持单继承（extends）多实现（implement）），在Java中取而代之的是简单的接口概念。

3网络技能

Java有一个扩展的例程库，用于处理像HTTP和FTP之类的TCP/IP协议。Java应用程序能够通过URL打开和访问网络上的对象，其便捷程度就好像访问本地文件一样。

4健壮性

Java的设计目标之一在于使得Java编写的程序具有多方面的可靠性。Java和c++最大的不同之处在于Java采用的指针模型可以消除重写内存和损坏数据的可能性。

Java编译器能够检测许多在其他语言中仅在运行时刻才能够检测出来的问题。

Java是绝对安全的，其原因是永远不会存取一个“坏的”指针，造成内存分配的错误，也不必防范内存泄漏。

Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。

5安全性

Java适用于网络/分布式环境。

从一开始，Java就设计成能够防范各种攻击，其中包括：
- 运行时堆栈溢出，如蠕虫病毒等常用的攻击手段。
- 在自己的处理空间之外破坏内存。
- 未经授权读写文件。
Java通过数字签名类，可以确定类的作者，如果信任这个类的作者，这个类就可以在你的机器上拥有更多的权限。

6体系结构中立

编译器生成一个体系结构中立的目标文件格式，这是一种编译过的代码，只要有Java系统运行时，就可以在许多处理器上运行。

Java编译器通过生成与特定的计算机体系结构无关的字节码指令来实现这一特性。

7可移植性

与c和c++不同，Java规范中没有“依赖具体实现”的地方。基本数据类型的大小以及有关算法都做了明确的说明。（例如Java中的int永远为32位的整数）

在Java中，数据类型具有固定的大小，这消除了代码移植时的问题。

二进制数据以固定的格式进行存储和传输。消除了字节顺序的困扰。字符串是用标准的Unicode格式存储的。

8解释型

Java解释器可以在任何移植了解释器的机器上执行Java字节码。

9高性能

尽管对解释后的字节码性能已经比较满意，但在有些场合下还需要更加高效的性能。字节码可以（在运行时刻）快速的翻译成运行这个应用程序的特定CPU的机器码。性能就是“适应性更强”。

10多线程

多线程可以带来更好的交互响应和实时行为。

Java中的线程可以利用多个处理器。

Java把多线程的实现交给了底层的操作系统或线程库来完成。

2：Java语言的核心内容
- 涵盖 java的基本语法结构、java的面向对象特征、java集合框架体系、java泛型、异常处理、java 注释、java的 io 流体系、java多线程编程、java网络通信编程和 java 反射机制；
- 覆盖了java.lang、java.util、java.text、java.io 和 java.nio、java.sql 包下绝大部分类和接口。
Read All
css

2019-01-16

百味皆苦

HTML与CSS

css
- 引入到HTML
- 常用选择器
引入到HTML

<link rel="stylesheet" type="text/css" href="css/style.css"/>

常用选择器

练习
- 父元素：直接包含子元素的元素
- 子元素：直接被父元素包含的元素
- 祖先元素：直接或间接包含后代元素的元素，父元素也是祖先元素
- 后代元素：直接或间接被祖先元素包含的元素，子元素也是后代元素
- 兄弟元素：拥有相同父元素的元素叫做兄弟元素
元素选择器
- 作用：通过元素选择器可以选则页面中的所有指定元素
- 语法：标签名 {}
```
p{
	color: red;
}

h1{
	color: red;
}
```
id选择器
- 通过元素的id属性值选中唯一的一个元素
- 语法：#id属性值 {}
```
#p1{
	font-size: 20px;
}
```
类选择器
- 通过元素的class属性值选中一组元素
- 语法：.class属性值{}
```
.p2{
	color: red;
}

.hello{
	font-size: 50px;
}
```
选择器分组(并集选择器)
- 通过选择器分组可以同时选中多个选择器对应的元素
- 语法：选择器1,选择器2,选择器N{}
```
#p1 , .p2 , h1{
	background-color: yellow;
}
```
复合选择器（交集选择器）
- 作用：可以选中同时满足多个选择器的元素
- 语法：选择器1选择器2选择器N{}
```
span.p3{
	background-color: yellow;
}
```
后代元素选择器
- 作用：选中指定元素的指定后代元素
  - 语法：祖先元素（空格）后代元素{}
```
#d1 span{
	color: greenyellow;
}
```
子元素选择器
- 作用：选中指定父元素的指定子元素
- 语法：父元素 > 子元素
```
#head > span{
	background-color: yellow;
}
```
- :first-child 可以选中第一个子元素
- :last-child 可以选中最后一个子元素
- :nth-child 可以选中任意位置的子元素,该选择器后边可以指定一个参数，指定要选中第几个子元素,even 表示偶数位置的子元素,odd 表示奇数位置的子元素
- :first-of-type在当前类型的子元素中排列
- :last-of-type
- :nth-of-type
```
body > p:first-child{
	background-color: yellow;
}
p:last-child{
	background-color: yellow;
}
p:nth-child(odd){
	background-color: yellow;
}
```
Read All

55/58

Welcome to My Blog!

java基础复习八Java集合

ArrayList

区别数组

数组局限

存放对象

常用方法

增加

判断

获取

位置

删除

替换

大小

变数组

加所有

清空

List接口

API

泛型

遍历

for

迭代器

java基础复习-Java介绍

1：Java语言的主要特性

1简单性

2面向对象

3网络技能

4健壮性

5安全性

6体系结构中立

7可移植性

8解释型

9高性能

10多线程

2：Java语言的核心内容

css

引入到HTML

常用选择器

元素选择器

id选择器

类选择器

选择器分组(并集选择器)

复合选择器（交集选择器）

后代元素选择器

子元素选择器