java笔记

最新推荐文章于 2023-12-30 22:08:53 发布

183 陈镜宇

最新推荐文章于 2023-12-30 22:08:53 发布

阅读量125

点赞数

文章标签： java spring 开发语言

本文链接：https://blog.csdn.net/qq_62196001/article/details/128054720

版权

Java笔记 1126

注解,就是对某一事物进行添加注释说明，会存放一些信息，这些信息可能对以后某个时段来说是很有用处的。
Java注解又叫java标注，java提供了一套机制，使得我们可以对方法、类、参数、包、域以及变量等添加标准(即附上某些信息)。且在以后某个时段通过反射将标注的信息提取出来以供使用。

Java从1.5版本以后默认内置三个标注：
@Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。
@Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上.
@SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭.
但是，仅仅这三个标注是不能满足我们开发时一些需求的。所以java允许我们自定义注解来使用。
自定义步骤大致分为两步：
1)，通过@interface关键字(注意，不是interface，是@interace)声明注解名称，以及注解的成员属性或者叫做注解的参数。
2)，使用java内置的四个元注解对这个自定义标注的功能和范围进行一些限制
元注解，就是定义注解的注解，也就是说这些元注解是的作用就是专门用来约束其它注解的注解。请区别上面那三个注解，他们也是通过元注解定义而来的。
元注解有哪些呢，主要有四个@Target,@Retention,@Documented,@Inherited
元注解有：@Target,@Retention,@Documented,@Inherited

@Target 表示该注解用于什么地方，可能的 ElemenetType 参数包括：
ElemenetType.CONSTRUCTOR 构造器声明
ElemenetType.FIELD 域声明（包括 enum 实例）
ElemenetType.LOCAL_VARIABLE 局部变量声明
ElemenetType.METHOD 方法声明
ElemenetType.PACKAGE 包声明
ElemenetType.PARAMETER 参数声明
ElemenetType.TYPE 类，接口（包括注解类型）或enum声明

@Retention 表示在什么级别保存该注解信息。可选的 RetentionPolicy 参数包括：
RetentionPolicy.SOURCE 注解将被编译器丢弃
RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃
RetentionPolicy.RUNTIME VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息。

@Documented 将此注解包含在 javadoc 中

@Inherited 允许子类继承父类中的注解
Stack 类
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。
Stack()
除了由Vector定义的所有方法，自己也定义了一些方法：
序号 方法描述
1 boolean empty()
测试堆栈是否为空。
2 Object peek( )
查看堆栈顶部的对象，但不从堆栈中移除它。
3 Object pop( )
移除堆栈顶部的对象，并作为此函数的值返回该对象。
4 Object push(Object element)
把项压入堆栈顶部。
5 int search(Object element)
返回对象在堆栈中的位置，以 1 为基数。
实例
import java.util.*; public class StackDemo { static void showpush(Stack<Integer> st, int a) { st.push(new Integer(a)); System.out.println("push(" + a + ")"); System.out.println("stack: " + st); } static void showpop(Stack<Integer> st) { System.out.print("pop -> "); Integer a = (Integer) st.pop(); System.out.println(a); System.out.println("stack: " + st); } public static void main(String args[]) { Stack<Integer> st = new Stack<Integer>(); System.out.println("stack: " + st); showpush(st, 42); showpush(st, 66); showpush(st, 99); showpop(st); showpop(st); showpop(st); try { showpop(st); } catch (EmptyStackException e) { System.out.println("empty stack"); } } }
以上实例编译运行结果如下：
stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。
然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。
Hashtable定义了四个构造方法。第一个是默认构造方法：
Hashtable()
第二个构造函数创建指定大小的哈希表：
Hashtable(int size)
第三个构造方法创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例。
填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度：
Hashtable(int size,float fillRatio)
第四个构造方法创建了一个以M中元素为初始化元素的哈希表。
哈希表的容量被设置为M的两倍。
Hashtable(Map m)
Hashtable中除了从Map接口中定义的方法外，还定义了以下方法：
序号   方法描述
1   void clear( )
将此哈希表清空，使其不包含任何键。
2   Object clone( )
创建此哈希表的浅表副本。
3   boolean contains(Object value)
测试此映射表中是否存在与指定值关联的键。
4   boolean containsKey(Object key)
测试指定对象是否为此哈希表中的键。
5   boolean containsValue(Object value)
如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
6   Enumeration elements( )
返回此哈希表中的值的枚举。
7   Object get(Object key)
返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
8   boolean isEmpty( )
测试此哈希表是否没有键映射到值。
9   Enumeration keys( )
返回此哈希表中的键的枚举。
10   Object put(Object key, Object value)
将指定 key 映射到此哈希表中的指定 value。
11   void rehash( )
增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。
12   Object remove(Object key)
从哈希表中移除该键及其相应的值。
13   int size( )
返回此哈希表中的键的数量。
14   String toString( )
返回此 Hashtable 对象的字符串表示形式，其形式为 ASCII 字符 ", " （逗号加空格）分隔开的、括在括号中的一组条目。
实例
下面的程序说明这个数据结构支持的几个方法：
import java.util.*;

public class HashTableDemo {

public static void main(String args[]) {
// Create a hash map
Hashtable balance = new Hashtable();
Enumeration names;
String str;
double bal;

balance.put("Zara", new Double(3434.34));
balance.put("Mahnaz", new Double(123.22));
balance.put("Ayan", new Double(1378.00));
balance.put("Daisy", new Double(99.22));
balance.put("Qadir", new Double(-19.08));

// Show all balances in hash table.
names = balance.keys();
while(names.hasMoreElements()) {
str = (String) names.nextElement();
System.out.println(str + ": " +
balance.get(str));
}
System.out.println();
// Deposit 1,000 into Zara's account
bal = ((Double)balance.get("Zara")).doubleValue();
balance.put("Zara", new Double(bal+1000));
System.out.println("Zara's new balance: " +
balance.get("Zara"));
}
}
以上实例编译运行结果如下：
Qadir: -19.08
Zara: 3434.34
Mahnaz: 123.22
Daisy: 99.22
Ayan: 1378.0

Zara's new balance: 4434.34
所有 Java 注解类型都继承于 java.lang.annotation.Annotation 接口，该接口代表程序中可以接收注解的程序元素。该接口主要有如下几个实现类。
Class：类定义
Constructor：构造方法定义
Field：类的成员变量定义
Method：类的方法定义
Package：类的包定义
java.lang.reflect 包下主要包含一些实现反射功能的工具类，从 Java 5 开始，java.lang.reflect 包所提供的反射 API 增加了读取运行时注解的能力。只有当定义注解时使用了 @Retention(RetentionPolicy.RUNTIME) 修饰，该注解才会在运行时可见。
AnnotatedElement 接口是所有程序元素（如 Class、Method、Constructor 等）的父接口，所以程序通过反射获取了某个类的 AnnotatedElement 对象（如 Class、Method、 Constructor 等）之后，程序就可以调用该对象的如下几个方法来访问注解信息
getDeclaredAnnotationXXXX：只可以获取直接存在的注解信息，即直接修饰在某个元素（类、属性和方法）上的注解。
getXXXXByType：可以获取间接存在的注解信息
getAnnotationXXX：可以获取继承的注解信息
注意：所有的方法都可以获取直接注解信息
Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：
•   Vector 是同步访问的。
•   Vector 包含了许多传统的方法，这些方法不属于集合框架。
Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。
Vector 类支持 4 种构造方法。
第一种构造方法创建一个默认的向量，默认大小为 10：
Vector()
第二种构造方法创建指定大小的向量。
Vector(int size)
第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目。
Vector(int size,int incr)
第四种构造方法创建一个包含集合 c 元素的向量：
Vector(Collection c)
除了从父类继承的方法外 Vector 还定义了以下方法：
序号   方法描述
1   void add(int index, Object element)
在此向量的指定位置插入指定的元素。
2   boolean add(Object o)
将指定元素添加到此向量的末尾。
3   boolean addAll(Collection c)
将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
4   boolean addAll(int index, Collection c)
在指定位置将指定 Collection 中的所有元素插入到此向量中。
5   void addElement(Object obj)
将指定的组件添加到此向量的末尾，将其大小增加 1。
6   int capacity()
返回此向量的当前容量。
7   void clear()
从此向量中移除所有元素。
8   Object clone()
返回向量的一个副本。
9   boolean contains(Object elem)
如果此向量包含指定的元素，则返回 true。
10   boolean containsAll(Collection c)
如果此向量包含指定 Collection 中的所有元素，则返回 true。
import java.util.*;

public class VectorDemo {

public static void main(String args[]) {
// initial size is 3, increment is 2
Vector v = new Vector(3, 2);
System.out.println("Initial size: " + v.size());
System.out.println("Initial capacity: " +
v.capacity());
v.addElement(new Integer(1));
v.addElement(new Integer(2));
v.addElement(new Integer(3));
v.addElement(new Integer(4));
System.out.println("Capacity after four additions: " +
v.capacity());

v.addElement(new Double(5.45));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Double(6.08));
v.addElement(new Integer(7));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Float(9.4));
v.addElement(new Integer(10));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Integer(11));
v.addElement(new Integer(12));
System.out.println("First element: " +
(Integer)v.firstElement());
System.out.println("Last element: " +
(Integer)v.lastElement());
if(v.contains(new Integer(3)))
System.out.println("Vector contains 3.");
// enumerate the elements in the vector.
Enumeration vEnum = v.elements();
System.out.println("\nElements in vector:");
while(vEnum.hasMoreElements())
System.out.print(vEnum.nextElement() + " ");
System.out.println();
}
}
以上实例编译运行结果如下：
Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3.

Elements in vector:
1 2 3 4 5.45 6.08 7 9.4 10 11 12

利用反射获取为类属性赋值

// 通过属性获取传入对象的指定属性的值 public String getValueByPropName(Student student,String propName) { String value = null; try { // 通过属性获取对象的属性 //.getDeclaredFields() 获得某个类的所有声明的字段，即包括public、private和proteced但不包括父类申明字段 //.getClass() 是⼀个对象实例的⽅法，只有对象实例才有这个⽅法，具体的类是没有的 Field field = student.getClass().getDeclaredField(propName); // 对象的属性的访问权限设置为可访问 //允许获取实体类private的参数信息 field.setAccessible(true); // 获取属性的对应的值 value = field.get(student).toString(); } catch (Exception e) { return null; } return value; } //主程序 public class TestReflectSet { private String readOnly; public String getReadOnly() { return readOnly; } public void setReadOnly( String readOnly ) { System.out.println("set"); this.readOnly = readOnly; } } //方法1： TestReflectSet t = new TestReflectSet(); //得到一个类的Field 属性， Field f = t.getClass().getDeclaredField("readOnly"); //然后设置可见性，然后设置了一个值，最后打印 f.setAccessible(true); f.set(t, "test"); System.out.println(t.getReadOnly()); //通过调用属性的set方法来完成赋值。 Method setReadOnly = t.getClass().getMethod("setReadOnly", String.class); String s ="test2"; setReadOnly.invoke(t,s); System.out.println(t.getReadOnly());

单元测试——JUnit
JUnit是一个开放源代码的测试工具，提供注解来识别测试方法。
JUnit测试可以让你编写代码更快，并能提高质量。
JUnit优雅简洁。没那么复杂，花费时间较少。
JUnit在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。

Properties 继承于 Hashtable。表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
Properties 类被许多 Java 类使用。例如，在获取环境变量时它就作为 System.getProperties() 方法的返回值。
Properties 定义如下实例变量.这个变量持有一个 Properties 对象相关的默认属性列表。
Properties defaults;
Properties类定义了两个构造方法. 第一个构造方法没有默认值。
Properties()
第二个构造方法使用propDefault 作为默认值。两种情况下，属性列表都为空：
Properties(Properties propDefault)
除了从 Hashtable 中所定义的方法，Properties 还定义了以下方法：
序号   方法描述
1   String getProperty(String key)
用指定的键在此属性列表中搜索属性。
2   String getProperty(String key, String defaultProperty)
用指定的键在属性列表中搜索属性。
3   void list(PrintStream streamOut)
将属性列表输出到指定的输出流。
4   void list(PrintWriter streamOut)
将属性列表输出到指定的输出流。
5   void load(InputStream streamIn) throws IOException
从输入流中读取属性列表（键和元素对）。
6   Enumeration propertyNames( )
按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
7   Object setProperty(String key, String value)
调用 Hashtable 的方法 put。
8   void store(OutputStream streamOut, String description)
以适合使用 load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
实例
下面的程序说明这个数据结构支持的几个方法：
实例
import java.util.*; public class PropDemo { public static void main(String args[]) { Properties capitals = new Properties(); Set states; String str; capitals.put("Illinois", "Springfield"); capitals.put("Missouri", "Jefferson City"); capitals.put("Washington", "Olympia"); capitals.put("California", "Sacramento"); capitals.put("Indiana", "Indianapolis"); // Show all states and capitals in hashtable. states = capitals.keySet(); // get set-view of keys Iterator itr = states.iterator(); while(itr.hasNext()) { str = (String) itr.next(); System.out.println("The capital of " + str + " is " + capitals.getProperty(str) + "."); } System.out.println(); // look for state not in list -- specify default str = capitals.getProperty("Florida", "Not Found"); System.out.println("The capital of Florida is " + str + "."); } }
以上实例编译运行结果如下：
The capital of Missouri is Jefferson City.
The capital of Illinois is Springfield.
The capital of Indiana is Indianapolis.
The capital of California is Sacramento.
The capital of Washington is Olympia.

The capital of Florida is Not Found.
队列是一种特殊的线性表，遵循先入先出、后入后出的基本原则，一般来说，它只允许在表的前端进行删除操作，而在表的后端进行插入操作，但是java的某些队列运行在任何地方插入删除；比如我们常用的 LinkedList 集合，它实现了Queue 接口，因此，我们可以理解为 LinkedList 就是一个队列；
java队列特性
队列主要分为阻塞和非阻塞，有界和无界、单向链表和双向链表之分；
阻塞和非阻塞
阻塞队列
入列(添加元素)时，如果元素数量超过队列总数，会进行等待（阻塞），待队列的中的元素出列后，元素数量未超过队列总数时，就会解除阻塞状态，进而可以继续入列；
出列(删除元素)时，如果队列为空的情况下，也会进行等待（阻塞），待队列有值的时候即会解除阻塞状态，进而继续出列；
阻塞队列的好处是可以防止队列容器溢出；只要满了就会进行阻塞等待；也就不存在溢出的情况；
只要是阻塞队列，都是线程安全的；

非阻塞队列
不管出列还是入列，都不会进行阻塞，
入列时，如果元素数量超过队列总数，则会抛出异常，
出列时，如果队列为空，则取出空值；
一般情况下，非阻塞式队列使用的比较少，一般都用阻塞式的对象比较多；阻塞和非阻塞队列在使用上的最大区别就是阻塞队列提供了以下2个方法：
• 出队阻塞方法： take()
• 入队阻塞方法： put()
有界和无界
有界：有界限，大小长度受限制
无界：无限大小，其实说是无限大小，其实是有界限的，只不过超过界限时就会进行扩容，就行ArrayList 一样，在内部动态扩容
XML 被设计用来传输和存储数据。
HTML 被设计用来显示数据。
XML 指可扩展标记语言（eXtensible Markup Language）。
可扩展标记语言（英语：Extensible Markup Language，简称：XML）是一种标记语言，是从标准通用标记语言（SGML）中简化修改出来的。它主要用到的有可扩展标记语言、可扩展样式语言（XSL）、XBRL和XPath等。
• XML 指可扩展标记语言（EXtensible Markup Language）。
• XML 是一种很像HTML的标记语言。
• XML 的设计宗旨是传输数据，而不是显示数据。
• XML 标签没有被预定义。您需要自行定义标签。
• XML 被设计为具有自我描述性。
• XML 是 W3C 的推荐标准。
________________________________________
________________________________________
XML 不会做任何事情
下面实例是 Jani 写给 Tove 的便签，存储为 XML：
<note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note>

XML 文档必须有根元素
XML 必须包含根元素，它是所有其他元素的父元素，比如以下实例中 root 就是根元素：
<root> <child> <subchild>.....</subchild> </child> </root>
以下实例中 note 是根元素：
<?xml version="1.0" encoding="UTF-8"?> <note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note>
________________________________________
XML 声明
XML 声明文件的可选部分，如果存在需要放在文档的第一行，如下所示：
<?xml version="1.0" encoding="utf-8"?>
所有的 XML 元素都必须有一个关闭标签
在 XML 中，省略关闭标签是非法的。所有元素都必须有关闭标签：
This is a paragraph.
 
XML 标签对大小写敏感
XML 标签对大小写敏感。标签 <Letter> 与标签 <letter> 是不同的。
必须使用相同的大小写来编写打开标签和关闭标签：
<Message>这是错误的</message>
<message>这是正确的</message>
XML 必须正确嵌套
在 XML 中，所有元素都必须彼此正确地嵌套：
This text is bold and italic
XML 属性值必须加引号
XML 中的注释
在 XML 中编写注释的语法与 HTML 的语法很相似。

________________________________________
在 XML 中，空格会被保留
________________________________________
XML 以 LF 存储换行
在 Windows 应用程序中，换行通常以一对字符来存储：回车符（CR）和换行符（LF）。
在 Unix 和 Mac OSX 中，使用 LF 来存储新行。
在旧的 Mac 系统中，使用 CR 来存储新行。
XML 以 LF 存储换行。

Xml约束
常用的约束技术有：
1. XML DTD；
2. XML Schema。
1. <!ELEMENT 书架 (书+)>
2. <!ELEMENT 书 (书名,作者,售价)>
3. <!ELEMENT 书名 (#PCDATA)>
4. <!ELEMENT 作者 (#PCDATA)>
5. <!ELEMENT 售价 (#PCDATA)>
PCDATA即parse character data(可解析的字符数据)，说白了就是字符串。注意：DTD文件应使用UTF-8或Unicode编码。
那么按照此DTD约束，写出来的book.xml文档如下：
1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE 书架 SYSTEM "book.dtd">
3. <书架>
4. <书>
5. <书名>Java就业培训教程</书名>
6. <作者>张孝祥</作者>
7. <售价>39.00元</售价>
8. </书>
9. <书>
10. <书名>JavaScript网页开发</书名>
11. <作者>张孝祥</作者>
12. <售价>28.00元</售价>
13. </书>
14. </书架>