StudyTonight-Java-中文教程-五-
StudyTonight Java 中文教程（五）
原文：StudyTonight
Java 中的复制构造器
原文：https://www.studytonight.com/java-examples/copy-constructor-in-java
复制构造器通过使用现有对象的值来创建新对象。复制构造器是其他克隆方法的替代方法，如可克隆接口。这些构造器可以创建浅克隆和深克隆。
在本教程中，我们将学习如何在 Java 中创建复制构造器。
复制简单类的构造器
复制构造器，就像任何其他构造器一样，应该与类同名。复制构造器将类的对象作为参数。它使用输入对象的值初始化字段。让我们为一个简单的学生类创建一个复制构造器，它包含一个字符串名称字段和一个双 GPA 字段。
class Student
{
private String name;
private double gpa;
//parameterized constructor
Student(String name, double gpa)
{
this.name = name;
this.gpa = gpa;
}
//Copy Constructor
Student(Student s)
{
this.name = s.getName();
this.gpa = s.getGpa();
}
//getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getGpa() {
return gpa;
}
public void setGpa(double gpa) {
this.gpa = gpa;
}
}
public class Demo
{
public static void main(String[] args)
{
Student s1 = new Student("Justin", 8.5);
Student cloneOfS1 = new Student(s1);
s1.setName("Jessica");//Changing the original object
System.out.println("Student-1: " + s1.getName());
System.out.print("Student-2: " + cloneOfS1.getName());
}
}
学生一:杰西卡
学生二:贾斯汀
我们可以看到，复制构造器创建了 s1 Student 对象的克隆。更改 s1 的值不会影响克隆的对象。
复制具有引用类型的类的构造器
在上一节中，复制构造器创建了一个浅克隆。但是由于 Student 类只包含原始类型或不可变字段，所以克隆不受原始对象变化的影响。
如果类字段是原始类型或不变的，那么浅层克隆和深层克隆是一样的。让我们在学生类中添加一个地址类字段，并从我们的构造器中创建一个浅拷贝。
class Student
{
private String name;
private double gpa;
private Address studentAddress;
//parameterized constructor
Student(String name, double gpa, Address add)
{
this.name = name;
this.gpa = gpa;
this.studentAddress = add;
}
//Copy Constructor
Student(Student s)
{
this.name = s.getName();
this.gpa = s.getGpa();
this.studentAddress = s.getStudentAddress();
}
//getters and setters
public Address getStudentAddress() {
return studentAddress;
}
public void setStudentAddress(Address studentAddress) {
this.studentAddress = studentAddress;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getGpa() {
return gpa;
}
public void setGpa(double gpa) {
this.gpa = gpa;
}
}
class Address
{
int postalCode;
Address(int s)
{
this.postalCode = s;
}
}
public class Demo
{
public static void main(String[] args)
{
Address add = new Address(10012);
Student s1 = new Student("Justin", 8.5, add);
Student cloneOfS1 = new Student(s1);
add.postalCode = 20012;//Altering the Address will affect the cloned object
System.out.println("Student-1: " + s1.getStudentAddress().postalCode);
System.out.print("Student-2: " + cloneOfS1.getStudentAddress().postalCode);
}
}
学生-1: 20012
学生-2: 20012
要创建深度副本，我们需要在构造器中创建一个新对象。更改引用不起作用。学生类的修改后的复制构造器如下所示。
//Copy Constructor
Student(Student s)
{
this.name = s.getName();
this.gpa = s.getGpa();
//creating a new address object
this.studentAddress = new Address(s.getStudentAddress().postalCode);
}
让我们使用上面的构造器并查看结果。
public class Demo
{
public static void main(String[] args)
{
Address add = new Address(10012);
Student s1 = new Student("Justin", 8.5, add);
Student cloneOfS1 = new Student(s1);
add.postalCode = 20012;
System.out.println("Student-1: " + s1.getStudentAddress().postalCode);
System.out.print("Student-2: " + cloneOfS1 .getStudentAddress().postalCode);
}
}
学生-1: 20012
学生-2: 10012
如上所示，更改原始对象不会影响克隆。这表明已创建深度拷贝。
复制构造器与克隆()方法
如前几节所述，覆盖可克隆接口的 clone()方法也可以创建深度拷贝。但是，使用复制构造器创建深度复制有一些优势。
- 创建和理解复制构造器要简单得多。使用可克隆接口，我们需要覆盖 clone()方法，并处理 CloneNotSupportedException。
- clone()方法返回一个对象引用，需要显式强制转换。
- 我们无法使用克隆方法将该值分配给最终字段。但是可以使用复制构造器来完成。
复制构造器的继承问题
复制构造器的一个缺点是它们不能被子类继承。如果使用父类引用子Class类型，那么我们就不能使用子类的复制构造器。下面的代码演示了这一点。
class ClassA
{
int x;
ClassA(int a)
{
this.x = a;
}
//copy constructor of Parent class
ClassA(ClassA object)
{
this.x = object.x;
}
}
class ClassB extends ClassA
{
int y;
ClassB(int a, int b)
{
super(a);
this.y = b;
}
//copy constructor of child class
ClassB(ClassB object)
{
super(object.x);
this.y = object.y;
}
}
public class Demo
{
public static void main(String[] args)
{
ClassA b = new ClassB(100, 200);//Assigning child type to parent reference
ClassB cloneB = new ClassB(b);//Compilation Error
}
}
线程“main”Java . lang . error:未解决的编译问题:
在 Demo.main(Demo.java:37)的构造器 ClassB(ClassA)未定义
我们可以通过使用显式强制转换来解决这个问题。但是如果对象不是子类，我们可能会得到一个 ClassCastException 。
public class Demo
{
public static void main(String[] args)
{
ClassA b = new ClassB(100, 200);
ClassB cloneB = new ClassB( (ClassB) b);//Using a cast
}
}
我们还可以在两个类中使用一个额外的方法来创建一个副本。这些方法将简单地调用它们的类的复制构造器。
class ClassA
{
int x;
ClassA(int a)
{
this.x = a;
}
//copy constructor
ClassA(ClassA object)
{
this.x = object.x;
}
// copyObject() method that uses the copy constructor
public ClassA copyObject()
{
return new ClassA(this);
}
}
class ClassB extends ClassA
{
int y;
ClassB(int a, int b)
{
super(a);
this.y = b;
}
//copy constructor
ClassB(ClassB object)
{
super(object.x);
this.y = object.y;
}
// copyObject() method that uses the copy constructor
public ClassB copyObject()
{
return new ClassB(this);
}
}
public class Demo
{
public static void main(String[] args)
{
ClassA b = new ClassB(100, 200);
ClassA cloneB = b.copyObject();
}
}
摘要
复制构造器是克隆对象的一种简单而优雅的方式。它们可以创建浅拷贝，也可以创建深拷贝。对于浅层克隆，我们只需要设置对输入对象字段的引用。但是对于深度拷贝，我们需要创建和分配新的对象。
复制构造器的一个缺点是它们是继承的。但是，我们可以通过在父类和子类中添加一个调用复制构造器的方法来克服这个缺点。
在 Java 中初始化HashMap
原文：https://www.studytonight.com/java-examples/initialize-hashmap-in-java
Hashtable用于存储键值对。在内部，它使用哈希来存储数据和获取数据。在本教程中，我们将学习如何在 Java 中初始化 HashMap。
使用 HashMap 的 put()方法
put()方法将键和值作为参数，并将键-值对添加到 HashMap 中。
import java.util.HashMap;
import java.util.Map;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> map = new HashMap<>();
map.put(101, "Justin");
map.put(102, "Jessica");
map.put(103, "Simon");
System.out.println(map);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
注意，我们只能在可变映射上使用这个方法。如果我们将此用于不可变映射，那么我们将获得不支持操作例外。
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> mutableMap = new HashMap<>();
mutableMap.put(101, "Justin");
mutableMap.put(102, "Jessica");
mutableMap.put(103, "Simon");
Map<Integer, String> immutableMap = Collections.unmodifiableMap(mutableMap);
immutableMap.put(104, "Harry");//Error
}
}
线程“main”Java . lang . unsupportedoperationexception
在 Java . base/Java . util . collections $ unmodifielemap . put(collections . Java:1473)
在 Demo.main(Demo.java:15)
创建单一映射
单值映射是一个不可变的映射，它存储一个单键值对。我们将使用collections . singletonmap()方法对其进行初始化。因为它是一个不可变的映射，所以我们不能向它添加多个条目。这将导致不支持操作例外。
import java.util.Collections;
import java.util.Map;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> singletonMap = Collections.singletonMap(101, "Justin");
System.out.print(singletonMap);
}
}
{ 101 =贾斯汀}
创建空映射
我们可以使用 Collections.emptyMap() 方法创建一个空的、不可变的映射。
import java.util.Collections;
import java.util.Map;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> emptyMap = Collections.emptyMap();
System.out.print(emptyMap);
}
}
{}
创建静态Hashtable
我们可以使用静态块在 Java 中创建和初始化一个静态 HashMap。下面的代码将创建一个静态可变映射。请注意，这种方法不是首选的，因为会创建额外的类，存储不需要的引用，并且可能会导致内存泄漏。
import java.util.HashMap;
import java.util.Map;
public class Demo
{
public static Map<Integer, String> staticMap;
static
{
staticMap = new HashMap<>();
staticMap.put(101, "Justin");
staticMap.put(102, "Jessica");
staticMap.put(103, "Simon");
}
public static void main(String[] args)
{
System.out.print(staticMap);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
在 Java 中 9 的 Map.of()方法
Map.of()是一个工厂方法，使用提供的键和值返回一个不可变的映射。这种方法的一个缺点是我们最多只能在映射上添加 10 个条目。如果我们试图添加 10 个以上的键值对，我们将会得到一个编译错误。
import java.util.Map;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> emptyMap = Map.of();
Map<Integer, String> singletonMap = Map.of(101, "Justin");
Map<Integer, String> map = Map.of(
101, "Justin",
102, "Jessica",
103, "Simon"
);
System.out.println(emptyMap);
System.out.println(singletonMap);
System.out.println(map);
}
}
{ }
{ 101 =贾斯汀}
在 Java 中 9 的 Map.ofEntries()方法
这种方法与()的 Map.of 基本相同。唯一不同的是，我们没有限制只有 10 个条目。就像 Map.of()方法一样，它返回一个不可变的映射。
import java.util.Map;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> emptyMap = Map.ofEntries();
Map<Integer, String> singletonMap = Map.ofEntries(Map.entry(101, "Justin"));
Map<Integer, String> map = Map.ofEntries(
Map.entry(101, "Justin"),
Map.entry(102, "Jessica"),
Map.entry(103, "Simon")
);
System.out.println(emptyMap);
System.out.println(singletonMap);
System.out.println(map);
}
}
{ }
{ 101 =贾斯汀}
使用谷歌番石榴图书馆
番石榴是著名的 Java 库。它提供了在 Java 中初始化可变和不可变映射的方法。为了初始化不可变的映射，我们将使用 ImmutableMap.of()方法。
import java.util.Map;
import com.google.common.collect.ImmutableMap;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> map = ImmutableMap.of(
101, "Justin",
102, "Jessica",
103, "Simon"
);
System.out.print(map);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
对于可变映射，我们将首先创建一个不可变映射。然后我们将它转换成一个可变的 HashMap。
import java.util.HashMap;
import java.util.Map;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> immutableMap = ImmutableMap.of(
101, "Justin",
102, "Jessica",
103, "Simon"
);
HashMap<Integer, String> mutableMap = Maps.newHashMap(immutableMap);
System.out.print(mutableMap);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
在 Java 中流初始化映射
Java 8 的流 API 提供了几种不同的方法来初始化映射。我们可以使用流创建可变和不可变的映射。但是，不建议使用以下初始化技术，因为它们会影响代码的整体性能并创建大量垃圾对象。
使用 Collectors.toMap()方法
我们可以使用一个二维对象数组(每行包含一个键值对)来创建一个流。然后，我们可以使用 toMap()方法将流式对象收集到我们的映射中。这将创建一个可变的映射。
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> map = Stream.of(new Object[][] {
{101, "Justin"},
{102, "Jessica"},
{103, "Simon"}
}).collect(Collectors.toMap(data -> (Integer) data[0], data -> (String) data[1]));
System.out.print(map);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
使用简单输入和简单置换输入
我们可以使用简单条目向映射添加键值条目。这将创建一个可变的映射。
import java.util.AbstractMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> map = Stream.of(
new AbstractMap.SimpleEntry<>(101, "Justin"),
new AbstractMap.SimpleEntry<>(102, "Jessica"),
new AbstractMap.SimpleEntry<>(103, "Simon")
).collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue));
System.out.print(map);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
同样，我们也可以使用 SimpleImmutableEntry。这种方法还会创建一个可变的映射。
import java.util.AbstractMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> map = Stream.of(
new AbstractMap.SimpleImmutableEntry<>(101, "Justin"),
new AbstractMap.SimpleImmutableEntry<>(102, "Jessica"),
new AbstractMap.SimpleImmutableEntry<>(103, "Simon")
).collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue));
System.out.print(map);
}
}
{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}
使用流初始化不可变映射
上面讨论的方法将创建一个可变的映射。但是我们也可以使用 Java 流来创建不可变的映射。这是通过使用collections . collectinganthen()来完成的。
import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo
{
public static void main(String[] args)
{
Map<Integer, String> immutableMap = Stream.of(new Object[][] {
{101, "Justin"},
{102, "Jessica"},
{103, "Simon"}
}).collect(Collectors.collectingAndThen(
Collectors.toMap(data -> (Integer) data[0], data -> (String)data[1]),
Collections::<Integer, String> unmodifiableMap));
System.out.println(immutableMap);
immutableMap.put(104, "Harry");//Error
}
}
{101=Justin，102=Jessica，103 = Simon }
Java . lang . unsupportedoperationexception
在 Java . base/Java . util . collections $ unmodifielemap . put(collections . Java:1473)
在 Demo.main(Demo.java:20)
摘要
Java 中的映射以许多不同的方式初始化。初始化 HashMaps 最简单的方法是使用 put()方法。但是我们不能用它来初始化不可变的映射。我们可以使用 Map.of()和 Map.ofEntries()方法来创建不可变的映射。流也用于创建可变和不可变的映射，但是它们降低了性能。
Java 堆内存错误
原文：https://www.studytonight.com/java-examples/java-heap-memory-error
使用任何编程语言时，错误和异常都很常见。在 Java 中，所有对象都存储在堆内存中， JVM 在无法为对象分配空间时抛出 OutOfMemoryError。有时这个错误也被称为 Java 堆空间错误。让我们进一步了解这个错误。
Java.lang.OutOfMemoryError 背后的原因
Java 有一个预定义的应用应该占用的最大内存量，如果应用超过这个限制，就会抛出 OutOfMemory 错误。让我们看看这个错误背后的原因。
- 出现这种错误可能是由于糟糕的编程实践，如使用低效的算法、错误的数据结构选择、无限循环、没有清除不需要的资源、将对象保存太长时间等。如果这是错误背后的原因，那么人们应该重新考虑在编写程序时所做的选择。
- 可能还有一些用户无法控制的其他原因。例如，缓存字符串的第三方库，或者部署后不清理的服务器。有时，即使堆和对象一切正常，也会出现这种错误。
- 内存泄漏也会导致内存不足错误。内存泄漏是指堆中存在未使用的对象，并且垃圾收集器无法移除该对象，因为它仍然有有效的引用。开放资源也可能导致内存泄漏，必须使用最终阻止来关闭它们。垃圾收集器将自动移除所有未引用的对象，这种情况可以通过让垃圾收集器可以使用未使用的对象来轻松避免。还提供了其他工具来检测和避免内存泄漏。
- 终结器的过度使用也会导致内存不足错误。具有 finalize 方法的类在垃圾收集时不会回收其对象空间。在垃圾收集过程之后，这些对象被排队等待稍后的终结，如果终结器线程跟不上队列，则会引发此错误。
我们总是可以增加 JVM 所需的内存，但是如果问题更严重，那么我们最终会耗尽内存。应该尝试优化代码，并查找可能导致此错误的内存泄漏。
示例:由于无限循环导致内存不足错误
让我们创建一个对象类型的ArrayList，并向其中无限地添加元素，直到内存耗尽。
import java.util.ArrayList;
public class OutOfMemory
{
public static void main(String args[])
{
ArrayList<Object> list = new ArrayList<Object>();
while(true)
{
Object o = new Object();
list.add(o);
}
}
}
在这个例子中，即使我们增加分配给应用的内存，我们最终也会用完空间。下图显示了上述程序返回的错误消息。
示例:由于内存有限，内存不足
如果分配给应用的内存少于所需内存，则返回内存不足错误。我们还可以尝试优化我们的代码，以便降低其空间复杂度。如果我们确信如果我们有更多的内存，这个错误可以被修复，那么我们可以通过使用 -Xmx 命令来增加它。让我们运行一个没有所需内存的程序。
public class OutOfMemoryError
{
public static void main(String[] args)
{
Integer[] outOfMemoryArray = new Integer[Integer.MAX_VALUE];
}
}
错误信息如下图所示。
通过增加堆空间解决内存不足问题
增加堆空间有时可以解决内存不足错误。如果我们确定没有内存泄漏，并且我们的代码不能进一步优化，那么增加堆空间可以解决我们的问题。我们将在运行 java 应用时使用 -Xmx 命令来增加堆空间。
例如，如果对内存设置 4MB 限制，以下代码将不起作用。
public class OutOfMemory
{
public static void main(String[] args)
{
String[] str = new String[1000000];
System.out.print("Memory Allocated");
}
}
然而，如果我们将限制增加到 8MB 或更大，那么它就可以完美地工作。
常见问题
问:Java 中的默认堆大小是多少？
Java 中的默认堆大小是 1GB，对于大多数任务来说已经足够了。
问:-Xmx 和-Xms 有什么区别？
Xms 定义初始或最小堆大小，xmx 用于设置最大堆大小。JVM 将启动由-xms 定义的内存，并且不会超过由-xmx 设置的限制。
问:什么是栈内存？
栈内存是后进先出内存，用于静态内存分配和线程执行。每当创建一个新对象时，它都存储在堆内存中，对它的引用存储在栈内存中。
摘要
OutOfMemoryError 是 VirtualMachineError 的一个子类，当 JVM 没有足够的空间来分配新对象时抛出。这个错误可能是由于糟糕的编程实践造成的，比如使用无限循环或者不清除不想要的对象。这也可能是由于某些第三方库的存在。内存泄漏也会导致这个错误我们可以使用 Eclipse Memory Analyzer 之类的工具来修复。有时候，仅仅增加分配给应用的堆空间就能解决问题。我们还应该尝试寻找优化的算法，以便我们程序的整体空间复杂度小于最大可用空间。
Java InvocationTargetException
原文：https://www.studytonight.com/java-examples/java-invocationtargetexception
InvocationTargetException 是在 Java 中使用反射层时出现的选中异常。反射 API 用于在运行时检查 Java 中的类、字段、方法和接口。
它让我们分析类及其方法的行为，即使我们不知道它们的名称。InvocationTargetException是使用反射时经常遇到的错误。
在本教程中，我们将了解有关此错误以及如何解决它的更多信息。
Java 中出现InvocationTargetException的原因
当我们调用或调用一个返回异常的方法时，就会出现InvocationTargetException。被调用方法返回的实际异常由 InvocationTargetException 包装。
考虑下面的例子，其中我们有一个名为 Sample 的类。我们在这个类中有一个总是返回ArrayIndexOutOfBounds异常的方法。当我们使用**invoke()**方法调用这个方法时，我们将得到InvocationTargetException。
import java.lang.reflect.Method;
class Sample
{
public void indexOutOfBoundsMethod()
{
int[] arr = new int[10];
System.out.print(arr[11]);
}
}
public class InvocationException
{
public static void main(String[] args)
{
try
{
Sample s = new Sample();
Method m = Sample.class.getMethod("indexOutOfBoundsMethod");
m.invoke(s);
}
catch(Exception e)
{
System.out.print(e);
}
}
}
Java . lang . reflect . invocationtargetexception
最初的异常没有显示给用户，这样用户就可以知道错误是由于通过反射调用方法还是由于我们当前方法中的一些其他问题而发生的。例如，如果我们在 main()方法中有一个大小为 10 的数组，并且我们试图访问它的第 11 个元素，那么我们会得到一个 ArrayIndexOutOfBounds 异常。现在，如果被调用的方法也显示了相同的 ArrayIndexOutOfBounds 异常，那么将很难理解异常的来源。
解析 Java 中的InvocationTargetException
如果我们知道被调用方法中异常的实际原因，我们可以很容易地解决这个异常。我们可以对异常使用**getCause()**方法，这将在调用的方法中返回底层异常。让我们在前面的例子中使用这个方法，并查看输出。
import java.lang.reflect.Method;
class Sample
{
public void indexOutOfBoundsMethod()
{
int[] arr = new int[10];
System.out.print(arr[11]);
}
}
public class demo
{
public static void main(String[] args)
{
try
{
Sample s = new Sample();
Method m = Sample.class.getMethod("indexOutOfBoundsMethod");
m.invoke(s);
}
catch(Exception e)
{
System.out.print(e.getCause());
}
}
}
Java . lang . arrayindexoutofboundsexception:长度为 10 的索引 11 超出范围
在一些罕见的情况下，我们可能需要多次使用getCause() 方法。例如，如果一个类方法本身使用反射并调用其他类的方法，而我们试图调用该类的这个方法，那么我们需要使用getCause()方法两次。下面的代码解释了这种情况。
import java.lang.reflect.Method;
class Sample1
{
public void indexOutOfBounds()//Method that always throws IndexOutOfBounds
{
int[] arr = new int[10];
System.out.print(arr[11]);
}
}
class Sample2
{
public void invokeIndexOutOfBounds() throws Exception
{
try
{
Sample1 s = new Sample1();
Method m = Sample1.class.getMethod("indexOutOfBounds");
m.invoke(s);//Invoking the method with the exception
}
catch(Exception e)
{
throw e;//this Exception e is itself an InvocationTargetException
}
}
}
public class demo
{
public static void main(String[] args)
{
try
{
Sample2 s = new Sample2();
Method m = Sample2.class.getMethod("invokeIndexOutOfBounds");
m.invoke(s);//invokeIndexOutOfBounds() throws the InvocationTargetException
}
catch(Exception e)
{
System.out.println(e);//Exception of the main() method
System.out.println(e.getCause());//Exception of the invokeIndexOutOfBounds() method
System.out.println(e.getCause().getCause());//Exception of the indexOutOfBounds() method
}
}
}
Java . lang . reflect . invocationtargetexception
Java . lang . reflect . invocationtargetexception
Java . lang . arrayindexoutofboundsexception:索引 11 超出长度 10 的界限
摘要
InvocationTargetException是使用反射 API 时可能出现的常见异常。发生这种情况是因为invoke() 是在返回异常的方法上调用的。被调用方法的基础异常由 InvocationTargetException 包装。我们可以通过使用getCause()方法轻松查看潜在的错误。
Servlet
基础
Servlet：Web 简介
原文：https://www.studytonight.com/servlet/introduction-to-web.php
Web 由通过有线和无线网络连接的数十亿个客户端和服务器组成。网络客户端向网络服务器发出请求。web 服务器接收请求，找到资源，并将响应返回给客户端。当服务器响应请求时，它通常会向客户端发送某种类型的内容。客户端使用网络浏览器向服务器发送请求。服务器通常用一组用超文本标记语言编写的指令向浏览器发送响应。所有浏览器都知道如何向客户端显示 HTML 页面。
网络应用
网站是静态文件(网页)的集合，如 HTML 页面、图像、图形等。一个 Web 应用是一个在服务器上有动态功能的网站。谷歌、脸书、推特都是网络应用的例子。
超文本传输协议
- HTTP 是客户端和服务器在网络上用来通信的协议。
- 它类似于其他互联网协议，如 SMTP(简单邮件传输协议)和 FTP(文件传输协议)，但有一个根本区别。
- HTTP 是一个无状态协议，也就是说 HTTP 每个连接只支持一个请求。这意味着使用 HTTP，客户端连接到服务器发送一个请求，然后断开连接。这种机制允许更多的用户在一段时间内连接到给定的服务器。
- 客户端发送一个 HTTP 请求，服务器使用 HTTP 用一个 HTML 页面回答客户端。
HTTP 方法
HTTP 请求可以使用多种方法，但是你最常用的是获取和发布。方法名告诉服务器正在发出的请求的类型，以及消息的其余部分将如何格式化。
HTTP 方法和说明:
|
|
|
| --- | --- |
| 选择 | 请求/响应链上可用的通信选项请求。 |
| 得到 | 请求使用给定的 URI 从服务器检索信息。 |
| 头 | 与 GET 相同，只是它不返回消息体，只返回标题和状态行。 |
| 邮政 | 请求服务器接受包含在 HTTP 方法主体中的实体。 |
| 删除 | 请求服务器删除资源。 |
| 连接 | 保留用于可以切换为隧道的代理。 |
| 放 | 这和 POST 是一样的，但是 POST 是用来创建的，PUT 可以用来创建也可以用来更新。它用上传的内容替换目标资源的所有当前表示。 |
获取和发布请求之间的区别
|
|
|
| --- | --- |
| 数据以报头形式发送到服务器 | 数据在请求正文中发送 |
| 获取请求只能发送有限数量的数据 | 可以发送大量数据。 |
| 获取请求不安全，因为数据暴露在 URL 中 | 发布请求是安全的，因为数据没有在网址中公开。 |
| Get 请求可以加入书签，效率更高。 | 发布请求不能被书签标记。 |
PUT 和 POST 方法的一般区别
以下是 PUT 和 POST 方法之间的一些基本区别:
- 将发布到网址会在服务器定义的网址上创建子资源，而将发布到网址会在客户端定义的网址上创建/替换整个资源。
- POST 创建一个子资源，因此 POST 到
/books将创建一个资源，该资源将位于/books资源下。/books/1。两次发送相同的帖子请求将创建两个资源。 - PUT 用于在客户端已知的 URL 创建或替换资源。
- 当客户端在创建资源之前已经知道 url 时，PUT 必须用于 CREATE。
- PUT 会替换已知 url 处的资源(如果它已经存在)，因此两次发送相同的请求没有效果。换句话说，对 PUT 的调用是幂等的。
解析一个 HTTP GET 请求
Get 请求包含服务器的路径和添加到其中的参数。
解析一个 HTTP POST 请求
Post 请求用于在服务器上发出更复杂的请求。例如，如果用户用多个字段填写了一个表单，而应用希望将所有表单数据保存到数据库中。然后表单数据将在 POST 请求正文中发送到服务器，也称为消息正文。
Servlet 简介
原文：https://www.studytonight.com/servlet/introduction-to-servlet.php
Servlet 技术用于创建 web 应用。 Servlet 技术使用 Java 语言创建 web 应用。
Web 应用是驻留在 web 服务器上并构建动态网页的辅助应用。动态页面可以是随机选择显示图片的页面，甚至是显示当前时间的页面。
由于 Servlet 技术使用 Java，使用 Servlet 制作的网络应用是安全的、可扩展的和健壮的。
通用网关接口
在 Servlets 之前，CGI(通用网关接口)编程被用来创建网络应用。以下是 CGI 程序的工作原理:
- 用户单击一个链接，该链接包含指向动态页面而不是静态页面的 URL。
- 网址决定执行哪个 CGI 程序。
- 网络服务器在独立的操作系统外壳中运行 CGI 程序。外壳包括操作系统环境和执行 CGI 程序代码的过程。
- CGI 响应被发送回网络服务器，网络服务器将响应打包成一个 HTTP 响应，并将其发送回网络浏览器。
CGI 程序的缺点
- 高响应时间，因为 CGI 程序在自己的操作系统外壳中执行。
- CGI 是不可扩展的。
- CGI 程序并不总是安全的或者面向对象的。
- 它依赖于平台。
由于这些缺点，开发人员开始寻找更好的 CGI 解决方案。然后太阳微系统公司开发了 Servlet 作为超越传统 CGI 技术的解决方案。
使用 Servlets 的优势
- 响应时间更短，因为每个请求都在单独的线程中运行。
- Servlets 是可伸缩的。
- Servlets 是健壮的和面向对象的。
- Servlets 与平台无关。
Servlet API
Servlet API 由两个重要的包组成，它们封装了所有重要的类和接口，即:
- javax.servlet
- javax.servlet.http
javax.servlet的一些重要类和接口
| 接口 | 班 |
| 小型应用 | ServletInputStream |
| ServletContext | 对象 |
| servletconfig | ServletRequestWrapper |
| ServletRequest | ServletResponseWrapper |
| ServletResponse | ServletRequestEvent |
| 监听器 | ServletContextEvent |
| 请求调度器 | servletrequestartributeevent |
| 接口 | ServletContextAttributeEvent |
| 过滤器 | servlet 异常 |
| 对象 | 不可用异常 |
| 过滤链 | 父类 |
| ServletRequestListener | |
javax.servlet.http的一些重要类和接口
| 类和接口 |
| HttpServlet | HttpServletRequest |
| httpservletresponse-http servlet 回应 | HttpSessionAttributeListener |
| 会话 | HttpSessionListener |
| 饼干 | HttpSessionEvent |
Servlet 接口
在 Java 中，一个接口用于开发 servlet。这个接口被称为 servlet 接口。该接口由所有接口实现。servlet 接口用于 init()、service()和 destroy()方法的声明。服务器在 servlet 的生命周期中调用这些方法。servlet 调用 getServletConfig()方法来初始化参数。getServletInfo()方法用于提供重要信息。
Servlet 接口只提供了五种方法。这五种方法中，三种是 Servlet 生命周期方法，其余两种是非生命周期方法。
声明:
公共接口 Servlet
Servlet 接口的方法
| 没有。 | 方法 | 描述 |
| 1. | 公共 void init(ServletConfigconfig) | 它用于初始化 servlet。在 servlet 生命周期中，web 容器只调用它一次。 |
| 2. | public void service(servletrequesteq，ServletResponse res) | 它用于对所有传入的请求提供响应。web 容器每次为每个请求调用它。 |
| 3. | 公开作废销毁() | 它用于销毁 servlet。它在 servlet 的生命周期中只被调用一次。 |
| 4. | public servlet configgetservletconfig() | 用于获取 ServletConfig 的对象。 |
| 5. | 公共字符串 getServletInfo() | 它用于获取关于 servlet 的作者、版权等信息。 |
Eclipse 上的 Servlet 接口示例
为了创建 servlet 接口，下面是程序的目录结构:
以下是创建程序的步骤。
第一步:通过点击文件= >新建= >动态网页项目在 eclipse 上创建一个动态项目
第二步:现在创建一个 HTML 文件。
右键单击项目，然后单击 HTML 文件。给出文件名，然后点击完成按钮。
并写出下面的代码。
Index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>studytonight => servlet interface example</title>
</head>
<body>
<h1>studytonight.com</h1><br><br>
************************************<br><br>
<h3><a href="demo">Click here to proceed...</a></h3><br><br>
************************************<br><br>
</body>
</html>
第三步:现在在 web.xml 文件中添加下面的代码。
web.xml 文件是一个部署描述符。这里有所有的配置。
<?xmlversion="1.0"encoding="UTF-8"?>
<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"id="WebApp_ID"version="4.0">
<servlet>
<servlet-name>abc</servlet-name>
<servlet-class>DemoServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>abc</servlet-name>
<url-pattern>/demo</url-pattern>
</servlet-mapping>
</web-app>
步骤 4:现在接下来创建一个 servlet。为此创建一个类。给出包名和类名。
现在在类文件中添加下面的代码。
DemoServlet.java
import java.io.*;
import javax.servlet.*;
public class DemoServlet implements Servlet{
ServletConfig config=null;
public void init(ServletConfig config){
this.config=config;
}
public void service(ServletRequest req,ServletResponse res)
throws IOException,ServletException{
res.setContentType("text/html");
PrintWriter pwriter=res.getWriter();
pwriter.print("<html>");
pwriter.print("<body>");
pwriter.print("<h1>Hello Welcome to studytonight. This example is of servlet interface. </h1>");
pwriter.print("</body>");
pwriter.print("</html>");
}
public void destroy(){
System.out.println("servlet destroy");
}
public ServletConfig getServletConfig(){
return config;
}
public String getServletInfo(){
return "studytonight.com";
}
}
现在，运行代码。
要运行代码，右键单击项目并选择运行方式= >在服务器上运行。
下面是 index.html 页面。点击链接登陆 servlet 页面。
这是 servlet 页面。
HttpServlet 类
HttpServlet 也是一个抽象类。这个类给出了 Servlet 接口的各种service()方法的实现。
为了创建一个 servlet，我们应该创建一个扩展 HttpServlet 抽象类的类。我们将要创建的 Servlet 类不能覆盖service()方法。我们的 servlet 类将只覆盖doGet()和/或doPost()方法。
HttpServlet 类的service()方法监听请求流中的 Http 方法(GET、POST 等)，并基于 Http 方法类型调用doGet()或doPost()方法。
HttpServlet 接口的方法
| 没有。 | 方法 | 描述 |
| one | 公共作废服务(ServletRequest，ServletResponse res) | 它通过创建请求和响应对象来保护服务方法。 |
| Two | 受保护的无效服务(HttpServletRequest 请求，HttpServletResponse res) | 它用于接收服务方法。 |
| three | protected void doet(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，用于处理 GET 请求。 |
| four | protected void dopost(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，并处理 POST 请求。 |
| five | protected void dohead(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，并处理 HEAD 请求。 |
| six | protected void doooptions(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，并处理 OPTIONS 请求。 |
| seven | protected void doput(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，并处理 OPTIONS 请求。 |
| eight | protected void dotrace(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，并处理 TRACE 请求 |
| nine | protected void doelete(http servletrequest req，HttpServletResponse res) | 它由 web 容器调用，并处理 DELETE 请求。 |
| Ten | 受保护长 getlastpmodified(HttpServletrequest 请求) | 它用于获取上次修改 HttpServletRequest 的时间。 |
Eclipse 上的 HttpServlet 类示例
为了创建一个 HttpServlet 类，下面是程序的目录结构:
以下是创建程序的步骤。
第一步:通过点击文件= >新建= >动态网页项目在 eclipse 上创建一个动态项目
第二步:现在创建一个 HTML 文件。
右键单击项目，然后单击 HTML 文件。给出文件名，然后点击完成按钮。
并写出下面的代码。
Demo.html
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<form action="mar" align="center">
<h3 align="center">studytonight.com</h3>
<h3 align="center">--------------------------------------------------------</h3>
Enter marks of the following subjects<br><br><br>
Maths : <input type="text" name="num1"><br><br>
English : <input type="text" name="num2"><br><br>
Hindi : <input type="text" name="num3"><br><br>
Science : <input type="text" name="num4"><br><br>
Social Science : <input type="text" name="num5"><br><br>
IT : <input type="text" name="num6"><br><br>
<input type="submit">
</form>
</body>
</html>
第三步:现在在 web.xml 文件中添加下面的代码。
web.xml 文件是一个部署描述符。这里有所有的配置。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
< <servlet>
<servlet-name>abc2</servlet-name>
<servlet-class>marks</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>abc2</servlet-name>
<url-pattern>/mar</url-pattern>
</servlet-mapping>
</web-app>
步骤 4:现在接下来创建一个 servlet。为此创建一个类。给出包名和类名。
在类文件中添加下面的代码。
marks.java
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
public class marks extends HttpServlet{
public void service(ServletRequest req, ServletResponse res) throws IOException, ServletException
{
int i = Integer.parseInt(req.getParameter("num1"));
int j = Integer.parseInt(req.getParameter("num2"));
int k = Integer.parseInt(req.getParameter("num3"));
int l = Integer.parseInt(req.getParameter("num4"));
int m = Integer.parseInt(req.getParameter("num5"));
int n = Integer.parseInt(req.getParameter("num6"));
int total = i + j + k + l + m + n;
float avg = total / 6;
PrintWriter out = res.getWriter();
out.println("Maths : " + i );
out.println("English : " + j );
out.println("Hindi : " + k);
out.println("Science : " + l);
out.println("Social Science : " + m);
out.println("IT : " + n);
out.println("Total Marks : "+ total);
out.println("Average: "+avg);
}
}
现在，运行代码。
要运行代码，右键单击项目并选择运行方式= >在服务器上运行。
下面是 index.html 页面。点击链接登陆 servlet 页面。
这是 servlet 页面。
GenericServlet 类
在 Servlet 中，GenericServlet 是一个抽象类。这个类实现了 servlet、ServletConfig 和 Serializable 接口。这个类提供了大多数基本 servlet 方法的实现。这个类的协议是独立的，因为它可以处理任何类型的请求。
级:
泛型 Servlet 接口的方法
实现的接口:
java.io.Serializable、Servlet、ServletConfig
施工方:
GenericServlet():此构造器不执行任何操作。一切都由 init 方法初始化。
| 没有 | 方法 | 说明 |
| one | 公共 void init(ServletConfig 配置) | 它用于 servlet 的初始化。 |
| Two | 公共抽象 void 服务(ServletRequest 请求，ServletResponse 响应) | 它用于为传入的请求提供所有服务。当用户请求时，只有它调用。 |
| three | 公开作废销毁() | 它用于销毁 servlet。它在 servlet 的生命周期中只被调用一次。 |
| four | public servlet config getservletconfig() | 用于获取 ServletConfig 的对象 |
| five | 公共字符串 getServletInfo() | 它用于获取关于 servlet 的作者、版权等信息。 |
| six | 公共 void init() | 对于程序员来说，这是一个非常简单方便的方法。 |
| seven | public servlet context getservletcontext() | 它用于获取 servlet 的对象 |
| eight | 公共字符串 getInitParameter(字符串名称) | 它用于从给定的参数名称中获取所有参数值。 |
| nine | 公共枚举 getInitParameterNames() | 它用于获取在 web.xml 文件中定义的参数 |
| Ten | public String getServletName() | 它用于获取 servlet 对象的名称。 |
| Eleven | 公共作废日志(字符串消息) | 它用于在 servlet 日志文件中写入消息。 |
| Twelve | 公共无效日志(字符串消息，可抛出测试) | 它用于在 servlet 日志文件和栈跟踪中写入消息。 |
Eclipse 上的泛型 Servlet 接口示例
为了创建 GenericServlet 类，下面是程序的目录结构:
以下是创建程序的步骤
第一步:通过点击文件= >新建= >动态网页项目在 eclipse 上创建一个动态项目
第二步:现在创建一个 HTML 文件。
并写出下面的代码。
演示 2.html
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Studytonight.com</title>
</head>
<body>
<form action="sal" align="center">
<h3 align="center">studytonight.com</h3>
<h3 align="center">--------------------------------------------------------</h3><br><br>
Enter Basic Salary <input type="text" name="num1"><br><br>
Enter Basic DA <input type="text" name="num2"><br><br>
Enter Basic HRA <input type="text" name="num3"><br><br>
<input type="submit">
</form>
</body>
</html>
第三步:现在在 web.xml 文件中添加下面的代码。
web.xml 文件是一个部署描述符。这里有所有的配置。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
<display-name>Generic_Servlet</display-name>
<servlet>
<servlet-name>abc1</servlet-name>
<servlet-class>salary</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>abc1</servlet-name>
<url-pattern>/sal</url-pattern>
</servlet-mapping>
</web-app>
步骤 4:现在接下来创建一个 servlet。为此创建一个类。给出包名和类名。
在类文件中添加下面的代码。
salary.java
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class salary extends GenericServlet
{
/**
*
*/
private static final long serialVersionUID = 1L;
public void service(ServletRequest req, ServletResponse res) throws IOException, ServletException
{
int i = Integer.parseInt(req.getParameter("num1"));
int j = Integer.parseInt(req.getParameter("num2"));
int k = Integer.parseInt(req.getParameter("num3"));
int da = (j * i) / 100;
int hra = (k * i) / 100;
int g = i + da + hra;
PrintWriter out = res.getWriter();
out.println("studytonight.com");
out.println("DA : "+da);
out.println("HRA : "+hra);
out.println("Gross Salary : "+g);
}
}
现在，运行代码。
要运行代码，右键单击项目并选择运行方式= >在服务器上运行。
下面是 demo2.html 页面。点击链接登陆 servlet 页面。
这是 servlet 页面。
Servlet 应用是如何工作的
原文：https://www.studytonight.com/servlet/how-a-servlet-application-work.php
Web 容器负责管理 Java EE 应用的 servlets 和 JSP 页面的执行。
当一个请求进入一个 servlet 时，服务器将请求传递给网络容器。 Web 容器负责实例化 servlet 或者创建一个新的线程来处理请求。Web 容器的工作是获取对 servlet 的请求和响应。容器创建多个线程来处理对单个 servlet 的多个请求。
servlet 没有 main()方法。Web 容器管理一个 Servlet 实例的生命周期。
关于 Servlet 如何工作的快速修订
-
User sends request for a servlet by clicking a link that has URL to a servlet.
-
The container finds the servlet using deployment descriptor and creates two objects :
-
Then the container creates or allocates a thread for that request and calls the Servlet's
service()method and passes the request, response objects as arguments.
-
The
service()method, then decides which servlet method,doGet()ordoPost()to call, based on HTTP Request Method(Get, Post etc) sent by the client. Suppose the client sent an HTTP GET request, so theservice()will call Servlet'sdoGet()method.
-
Then the Servlet uses response object to write the response back to the client.
-
After the
service()method is completed the thread dies. And the request and response objects are ready for garbage collection.
Servlet 生命周期
原文：https://www.studytonight.com/servlet/servlet-life-cycle.php
-
加载 servlet 类:当 Web 容器收到对 Servlet 的第一个请求时，就会加载 Servlet 类。
-
Servlet 实例创建:加载 Servlet 类后，Web Container 创建它的实例。Servlet 实例在生命周期中只创建一次。
-
Call to the init() method :
init()method is called by the Web Container on servlet instance to initialize the servlet.init()方法签名:
public void **init**(ServletConfig config) throws ServletException -
Call to the service() method : The containers call the
service()method each time the request for servlet is received. The service() method will then call thedoGet()ordoPost()methos based ont eh type of the HTTP request, as explained in previous lessons.送达方式签字:
public void **service**(ServletRequest request, ServletResponse response) throws ServletException, IOException -
调用 destroy()方法:Web 容器在移除 servlet 实例之前调用
destroy()方法，给它一个清理活动的机会。
在 web.xml 中启动时加载
在 Java 中，默认情况下不会加载 servlet。当一个 servlet 容器收到一个请求时，只加载一个 servlet。第一次加载 servlet 时，与下一次相比，它需要更多的时间。如果您想避免访问时间的延迟，那么可以在 web.xml 文件中使用
以下是如何使用<开机加载>标签的示例。
Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
<servlet>
<servlet-name>abc</servlet-name>
<servlet-class>com.app.studytonight.AddServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
</web-app>
下面是如何使用<启动时加载>标签对多个 servlet 加载进行排序的示例。
Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
<servlet>
<servlet-name>abc1</servlet-name>
<servlet-class>com.app.studytonight.AddServlet1</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>abc2</servlet-name>
<servlet-class>com.app.studytonight.AddServlet2</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet>
<servlet-name>abc3</servlet-name>
<servlet-class>com.app.studytonight.AddServlet3</servlet-class>
<load-on-startup>3</load-on-startup>
</servlet>
<servlet>
<servlet-name>abc4</servlet-name>
<servlet-class>com.app.studytonight.AddServlet4</servlet-class>
<load-on-startup>-1</load-on-startup>
</servlet>
</web-app>
在上面的示例中，一旦服务器按照指定的顺序(即 1、2 和 3)启动，就会加载 com . app . study south . addservlet 1、com . app . study south . addservlet 2、com . app . study south . addservlet 3。但是当服务器启动时，不会加载 com . app . study south . addservlet 4，因为它有一个负值。负值将根据容器首选项加载。
使用 tomcat 服务器创建 Servlet 应用的步骤
原文：https://www.studytonight.com/servlet/steps-to-create-servlet-using-tomcat-server.php
要创建一个 Servlet 应用，您需要遵循下面提到的步骤。这些步骤对于所有的网络服务器都是通用的。在我们的例子中，我们使用的是 Apache Tomcat 服务器。Apache Tomcat 是一个用于测试 servlets 和 JSP 技术的开源 web 服务器。下载最新版本的 Tomcat 服务器并安装在你的机器上。
在您的机器上安装 Tomcat 服务器后，请遵循以下步骤:
- 为您的应用创建目录结构。
- 创建一个 Servlet
- 编译 Servlet
- 为应用创建部署描述符
- 启动服务器并部署应用
下面详细解释了这 5 个步骤，让我们创建第一个 Servlet 应用。
1.创建目录结构
Sun 微系统定义了创建 servlet 应用必须遵循的唯一目录结构。
在 Apache-Tomcat\webapps 目录中创建上述目录结构。所有 HTML、静态文件(图片、css 等)直接保存在网络应用文件夹下。而所有的 Servlet 类都保存在classes文件夹中。
web.xml(部署描述符)文件保存在WEB-INF文件夹下。
2.创建一个 Servlet
创建 servlet 有三种不同的方法。
- 通过实现 Servlet 接口
- 通过扩展泛型 Servlet 类
- 通过扩展 HttpServlet 类
但是通常一个 servlet 是通过扩展 HttpServlet 抽象类创建的。如前所述 HttpServlet 给出了 Servlet 接口的service()方法的定义。我们将要创建的 servlet 类不应该覆盖service()方法。我们的 servlet 类将只覆盖doGet()或doPost()方法。
当对 servlet 的请求到来时，网络容器调用 servlet 的service()方法，根据请求的类型，service()方法调用doGet()或doPost()方法。
注意:默认情况下，请求是获取请求。
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public MyServlet extends HttpServlet
{
public void doGet(HttpServletRequest request,HttpServletResposne response)
throws ServletException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><body>");
out.println("<h1>Hello Readers</h1>");
out.println("</body></html>");
}
}
将上述代码写在记事本文件中，并将其保存为您电脑上的任何地方的MyServlet.java。从那里编译它(在下一步中解释)，并将类文件粘贴到您必须在 Tomcat/webapps 目录中创建的WEB-INF/classes/目录中。
3.编译一个 Servlet
要编译一个 Servlet，需要一个 JAR 文件。不同的服务器需要不同的 JAR 文件。在 Apache Tomcat 服务器中servlet-api.jar文件是编译一个 servlet 类所必需的。
编译 Servlet 的步骤:
- 设置类路径。
- 下载 servlet-api.jar 文件。
- 将 servlet-api.jar 文件粘贴到
Java\jdk\jre\lib\ext目录中。
- 编译 Servlet 类。
注意:编译完你的 Servlet 类后，你必须将类文件粘贴到WEB-INF/classes/目录中。
4.创建部署描述符
部署描述符(DD) 是 Web 容器用来运行 Servlets 和 JSP 页面的 XML 文档。DD 用于几个重要目的，例如:
- 将 URL 映射到 Servlet 类。
- 初始化参数。
- 定义错误页面。
- 安全角色。
- 声明标记库。
我们将在后面详细讨论所有这些。现在我们将看到如何为我们的 web 应用创建一个简单的 web.xml 文件。
5.启动服务器
双击 startup.bat 文件启动你的 Apache Tomcat 服务器。
或者，使用 RUN 提示符在您的 windows 计算机上执行以下命令。
C:\apache-tomcat-7.0.14\bin\startup.bat
6.第一次启动 Tomcat 服务器
如果你是第一次启动 Tomcat 服务器，你需要在环境变量中设置 JAVA_HOME。以下步骤将向您展示如何设置它。
- 右键点击我的电脑，进入物业。
- 进入高级选项卡，点击环境变量...按钮。
- 点击新建按钮，在变量名文本字段中输入 JAVA_HOME ，在变量值文本字段中输入 JDK 的路径。单击确定保存。
7.运行 Servlet 应用
打开浏览器，输入http:localhost:8080/First/hello
万岁！我们的第一个 Servlet 应用成功运行。
使用 Netbeans IDE 创建第一个 Servlet 应用
原文：https://www.studytonight.com/servlet/creating-servlet-in-netbeans.php
在最后一课中，我们创建了第一个 Servlet 应用，但是没有使用任何 IDE。IDE 是 IDE，它使创建应用变得容易得多。我们将学习如何在 NetBeans IDE 和 Eclipse IDE 上创建 Servlet 应用。然后你可以决定你想用哪一个。
使用 IDE 是创建 Servlet 应用最简单的方法。IDE 是一种软件应用，为计算机程序员提供软件开发工具。 Eclipse 、mycplise、 Netbeans 都是一些流行 Java IDE 的例子。
在 Netbeans IDE 中创建 Servlet 应用的步骤
要在 Netbeans IDE 中创建 servlet 应用，您需要遵循以下(简单的)步骤:
-
Open Netbeans IDE, Select File -> New Project
-
Select Java Web -> Web Application, then click on Next,
-
Give a name to your project and click on Next,
-
and then, Click Finish
-
The complete directory structure required for the Servlet Application will be created automatically by the IDE.
- To create a Servlet, open Source Package, right click on default packages -> New -> Servlet.
- Give a Name to your Servlet class file,
- Now, your Servlet class is ready, and you just need to change the method definitions and you will good to go.
- Write some code inside your Servlet class.
- Create an HTML file, right click on Web Pages -> New -> HTML
- Give it a name. We recommend you to name it
index, because browser will always pick up theindex.htmlfile automatically from a directory. Index file is read as the first page of the web application.
- Write some code inside your HTML file. We have created a hyperlink to our Servlet in our HTML file.
- Edit web.xml file. In the web.xml file you can see, we have specified the url-pattern and the servlet-name, this means when
hellourl is accessed our Servlet file will be executed.
- Run your application, right click on your Project and select Run
- Click on the link created, to open your Servlet.
- Hurray! Our First Servlet class is running.
使用 Eclipse IDE 创建第一个 Servlet 应用
原文：https://www.studytonight.com/servlet/creating-servlet-in-eclipse.php
Eclipse IDE 是业界最流行的 Java IDE。它是由一个开源社区开发的，可以从免费下载
使用 Eclipse IDE 创建 Servlet 的步骤
要在 Eclipse IDE 中创建一个 Servlet 应用，您需要遵循以下步骤:
-
Goto File -> New -> Dynamic Web Project
-
Give a Name to your Project and click Next
-
Check Generate web.xml Deployment Descriptor and click Finish
-
Now, the complete directory structure of your Project will be automatically created by Eclipse IDE.
-
Click on First project, go to Java Resources -> src. Right click on src select New -> Servlet
- Give Servlet class name and click Next
- Give your Servlet class a Nmae of your choice.
- Leave everything else to default and click Finish
- Now your Servlet is created, write some code inside it. You can take reference from the code in the picture below.
- Add servlet-api.jar JAR file to your project. Click on Libraries, right click on Web App Libraries select Build Path -> Configure Build Path
- Click on Add External JARs
- 这个 JAR 现在被添加到项目的构建路径中。
- Select servlet-api.jar from Apache Tomcat Directory
- Now all you have to do is Start the server and run the application.
Eclipse 上的 Servlet 响应示例
步骤 1:在 eclipse 上创建一个动态项目。
第二步:现在创建一个 HTML 文件。
并写出下面的代码。
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<form action="display" method="get">
Enter User name: <input type="text" name="val1">
Enter Password: <input type="text" name="val2">
<input type="submit" value="login">
</form>
</body>
</html>
步骤 3:现在在 web.xml 文件中添加下面的代码。
web.xml 文件是一个部署描述符。这里有所有的配置。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
<servlet>
<servlet-name>abc3</servlet-name>
<servlet-class>com.app.studytonight.demo4</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>abc3</servlet-name>
<url-pattern>/display</url-pattern>
</servlet-mapping>
</web-app>
步骤 4:现在接下来创建一个 servlet。为此创建一个类。给出包名和类名。
在类文件中添加下面的代码。
演示 4.java
package com.app.studytonight;
import javax.servlet.http.*;
import javax.servlet.*;
import java.io.*;
public class demo4 extends HttpServlet{
public void doGet(HttpServletRequest req,HttpServletResponse res)
throws ServletException,IOException
{
res.setContentType("text/html");
PrintWriter pwriter=res.getWriter();
String uname=req.getParameter("val1");
String pw=req.getParameter("val2");
pwriter.println("User Details Page:");
pwriter.println("Hello "+uname);
pwriter.println("Your Password is **"+pw+"**");
pwriter.close();
}
}
现在，运行代码。
进阶
ServletRequest类简介
Servlet 的真正工作是处理客户端请求。Servlet API 提供了两个重要的接口javax . servlet . servlet request和javax . servlet . http . httpservletrequest封装客户端请求。这些接口的实现向 servlet 提供了关于客户端请求的重要信息。
服务请求的一些重要方法
| 方法 | 描述 |
| 对象getAttribute(String name) | 按名称返回请求对象的属性集 |
| 枚举getAttributeName() | 返回包含该请求中可用属性名称的枚举 |
| int getContentLength() | 请求正文的返回大小 |
| int getContentType() | 返回请求内容的媒体类型 |
| servletinputstream〔t0〕 | 返回用于读取二进制数据的输入流 |
| 弦getParameter(String name) | 按名称返回参数值 |
| 弦getLocalAddr() | 返回接收请求的接口的互联网协议地址 |
| 枚举getParameterNames() | 返回所有参数名称的枚举 |
| 字符串[] getParameterValues(String name) | 返回一个 String 对象数组，其中包含给定请求参数的所有值，如果参数不存在，则返回 null |
| servletcontext〔t0〕 | 返回当前请求的 servlet 上下文。 |
| 弦getServerName() | 返回向其发送请求的服务器的主机名 |
| int getServerPort() | 返回请求发送到的端口号 |
| 布尔值 isSecure() | 返回一个布尔值，指示此请求是否是使用安全通道(如 HTTPS)发出的。 |
| 作废removeAttribute(String name) | 从此请求中移除属性 |
| 作废setAttribute(String name, Object o) | 在此请求中存储一个属性。 |
HttpServletRequest 接口
httpersvletrequest接口增加了与 HTTP 协议相关的方法。
HttpServletRequest 的一些重要方法
| 方法 | 描述 |
| 弦getContextPath() | 返回 URI 请求中指示请求上下文的部分 |
| 饼干getCookies() | 返回一个数组，其中包含客户端随此请求发送的所有 Cookie 对象 |
| 弦getQueryString() | 返回路径后请求 URL 中包含的查询字符串 |
| http session〔t0〕 | 返回与此请求关联的当前 HttpSession，或者，如果没有当前会话并且 create 为 true，则返回新会话 |
| 弦getMethod() | 返回发出此请求的 HTTP 方法的名称，例如 GET、POST 或 PUT。 |
| 部分getPart(String name) | 获取具有给定名称的部件 |
| 弦getPathInfo() | 返回与客户端发出请求时发送的 URL 相关联的任何额外路径信息。 |
| 弦getServletPath() | 返回这个请求的 URL 中调用 servlet 的部分 |
演示 Servlet 请求的示例
在这个例子中，我们将展示一个参数是如何从 HTML 页面传递到请求对象中的 Servlet 的。
index.html
<form method="post" action="check">
Name <input type="text" name="user" >
<input type="submit" value="submit">
</form>
web.xml
<servlet>
<servlet-name>check</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>check</servlet-name>
<url-pattern>/check</url-pattern>
</servlet-mapping>
MyServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
String user = request.getParameter("user");
out.println("<h2> Welcome "+user+"</h2>");
} finally {
out.close();
}
}
}
输出:
ServletResponse简介
原文：https://www.studytonight.com/servlet/servlet-response.php
Servlet API 提供了两个重要的接口 ServletResponse 和httpersvletresponse来协助向客户端发送响应。
服务响应的一些重要方法
| 方法 | 描述 |
| PrintWriter getWriter() | 返回一个 PrintWriter 对象，该对象可以向客户端发送字符文本。 |
| 作废setBufferSize(int size) | 设置响应正文的首选缓冲区大小 |
| 作废setContentLength(int len) | 设置响应中内容主体的长度在 HTTP servlets 中，此方法设置 HTTP 内容长度头 |
| 作废setContentType(String type) | 在发送响应之前，设置发送给客户端的响应的内容类型。 |
| 作废setBufferSize(int size) | 设置响应正文的首选缓冲区大小。 |
| 布尔值 isCommitted() | 返回一个布尔值，指示响应是否已提交 |
| 作废setLocale(Locale loc) | 如果尚未提交响应，则设置响应的区域设置。 |
HttpServletResponse 接口
HttpServletResponse 接口添加了与 HTTP 响应相关的方法。它扩展了 ServletResponse 接口。HttpServletResponse 的对象是在 servlet 容器中创建的。
HttpServletResponse 的一些重要方法
| 方法 | 描述 |
| 作废addCookie(Cookie cookie) | 将指定的 cookie 添加到响应中。 |
| 作废sendRedirect(String location) | 使用指定的重定向位置 URL 向客户端发送临时重定向响应，并清除缓冲区 |
| int getStatus() | 获取此响应的当前状态代码 |
| 弦getHeader(String name) | 获取具有给定名称的响应头的值。 |
| 作废setHeader(String name, String value) | 使用给定的名称和值设置响应头 |
| 作废setStatus(int sc) | 设置此响应的状态代码 |
| 作废sendError(int sc, String msg) | 使用指定的状态向客户端发送错误响应，并清除缓冲区 |
Eclipse 上的 HttpServletResponse 接口示例
为了创建一个 HttpServletResponse 接口，下面是程序的目录结构:
以下是创建程序的步骤。
第一步:通过点击文件= >新建= >动态网页项目在 eclipse 上创建一个动态项目
第二步:现在创建一个 HTML 文件。
右键单击项目，然后单击 HTML 文件。给出文件名，然后点击完成按钮。
并写出下面的代码。
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>studytonight.com</title>
</head>
<body>
<form align="center" action="display" method="get">
<h3>studytonight.com</h3>
<hr>
Enter User name: <input type="text" name="val1"><br><br>
Enter Password: <input type="password" name="val2" ><br><br>
<input type="submit" value="login">
</body>
</html>
第三步:现在在 web.xml 文件中添加下面的代码。
web.xml 文件是一个部署描述符。这里有所有的配置。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
<display-name>ServletResponse</display-name>
<servlet>
<servlet-name>abc3</servlet-name>
<servlet-class>demo4</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>abc3</servlet-name>
<url-pattern>/display</url-pattern>
</servlet-mapping>
</web-app>
步骤 4:现在接下来创建一个 servlet。为此创建一个类。给出包名和类名。
在类文件中添加下面的代码。
演示 4.java
import javax.servlet.http.*;
import javax.servlet.*;
import java.io.*;
public class demo4 extends HttpServlet{
public void doGet(HttpServletRequest req,HttpServletResponse res)
throws ServletException,IOException
{
res.setContentType("text/html");
PrintWriter pwriter=res.getWriter();
String uname=req.getParameter("val1");
String pw=req.getParameter("val2");
pwriter.println("User Details Page:");
pwriter.println("Hello "+uname);
pwriter.println("Your Password is **"+pw+"**");
pwriter.close();
}
}
现在，运行代码
要运行代码，右键单击项目并选择运行方式= >在服务器上运行。
下面是 demo4.html 页面。填写所有字段，然后单击登录按钮登录 servlet 页面。
这是 servlet 页面。
Servlet 中的RequestDispatcher
原文：https://www.studytonight.com/servlet/request-dispatcher.php
在 Java 中，RequestDispatcher 接口用于将请求分派给资源，即 Html、servlet 或 JSP。另一个资源的内容可以包含在这个界面中。RequestDispatcher 有两种方法。它们如下:
Servlet:请求调度器的方法
RequestDispatcher 接口提供了两个重要的方法
| 方法 | 描述 |
| 公共 void forward(ServletRequest 请求，ServletResponse 响应)引发 ServletException，java.io.IOException | 它用于将请求从服务器上的一个 servlet 转发到另一个 servlet。 |
| public void include(servlet request 请求，ServletResponse 响应)抛出 ServletException，java.io.IOException | 它用于在响应中包含资源的内容。 |
forward()方法:
include()方法:
Eclipse 上 forward()和 include()方法的示例
使用 forward()和 include()方法创建程序时，下面是程序的目录结构:
以下是创建程序的步骤。
第一步:通过点击文件= >新建= >动态网页项目在 eclipse 上创建一个动态项目
第二步:现在创建一个 HTML 文件。
右键单击项目，然后单击 HTML 文件。给出文件名，然后点击完成按钮。
并写出下面的代码。
Index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>studytonight</title>
</head>
<body>
<form align="center" action="display" method="post">
<h3>studytonight.com</h3>
<hr>
Name: <input type="text" name="val1"><br> <br>
User Id: <input type="text" name="val2"><br> <br>
Password: <input type="password" name="val3"><br> <br>
<input type="submit" value="login">
</form>
</body>
</html>
步骤 3:现在在 web.xml 文件中添加下面的代码。
web.xml 文件是一个部署描述符。这里有所有的配置。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
<display-name>forward</display-name>
<servlet>
<servlet-name>demo5</servlet-name>
<servlet-class>forward.demo5</servlet-class>
</servlet>
<servlet>
<servlet-name>demo5i</servlet-name>
<servlet-class>forward.demo5i</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>demo5</servlet-name>
<url-pattern>/display</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>demo5i</servlet-name>
<url-pattern>/display1</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
步骤 4:现在接下来创建一个 servlet。为此创建一个类。给出包名和类名。
对于这个例子，我们需要两个 servlet 类。
现在在类文件中添加下面的代码。
演示 5.java
package forward;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class demo5 extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String n=request.getParameter("val1");
String u=request.getParameter("val2");
String p=request.getParameter("val3");
if(p.equals("studytonight"))
{
RequestDispatcher rd=request.getRequestDispatcher("display1");
rd.forward(request, response);
}
else{
out.print("Incorrect UserId or Password");
RequestDispatcher rd=request.getRequestDispatcher("/index.html");
rd.include(request, response);
}
}
}
演示。java
package forward;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class demo5i extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String n=request.getParameter("val2");
out.print("Welcome "+n);
}
}
现在，运行代码。
要运行代码，右键单击项目并选择运行方式= >在服务器上运行。
下面是 index.html 页面。填写所有字段，点击登录按钮登陆
servlet 页面。
如果你的密码是正确的，那么它将登陆 demo5.java 的 servlet 页面
如果你的密码不正确，它将登陆 demo5i.java 页面。
如何获取RequestDispatcher的对象
ServletRequest 的getRequestDispatcher()方法返回 RequestDispatcher 的对象。
RequestDispatcher rs = request.getRequestDispatcher("hello.html");
rs.forward(request,response);
或
RequestDispatcher rs = request.getRequestDispatcher("hello.html");
rs.include(request,response);
演示 RequestDispatcher 用法的示例
在本例中，我们将向您展示如何使用 RequestDispatcher 来转发或在 Servlet 中包含资源的响应。这里我们使用index.html从用户那里获取用户名和密码，验证 Servlet 将验证用户输入的密码，如果用户已经输入“今晚学习”作为密码，那么他将被转发到欢迎使用 Servlet，否则用户将停留在 index.html 页面并显示一条错误消息。
要创建的文件:
- index.html会有表单字段来获取用户信息。
- Validate.java将验证用户输入的数据。
- Welcome.java将成为欢迎页面。
- web.xml ，部署描述符。
index.html
<form method="post" action="Validate">
Name:<input type="text" name="user" /><br/>
Password:<input type="password" name="pass" ><br/>
<input type="submit" value="submit">
</form>
Validate.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Validate extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
String name = request.getParameter("user");
String password = request.getParameter("pass");
if(password.equals("studytonight"))
{
RequestDispatcher rd = request.getRequestDispatcher("Welcome");
rd.forward(request, response);
}
else
{
out.println("<font color='red'><b>You have entered incorrect password</b></font>");
RequestDispatcher rd = request.getRequestDispatcher("index.html");
rd.include(request, response);
}
}
finally {
out.close();
}
}
}
Welcome.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Welcome extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("<h2>Welcome user</h2>");
}
finally {
out.close();
}
}
}
web.xml
<web-app>
<servlet>
<servlet-name>Validate</servlet-name>
<servlet-class>Validate</servlet-class>
</servlet>
<servlet>
<servlet-name>Welcome</servlet-name>
<servlet-class>Welcome</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Validate</servlet-name>
<url-pattern>/Validate</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>Welcome</servlet-name>
<url-pattern>/Welcome</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
这将是第一个屏幕。您可以在此输入您的用户名和密码。
当您单击“提交”时，将验证密码，如果不是“今晚学习”，将显示错误消息。
输入任何用户名，但输入“今晚学习”作为密码。
密码将被成功验证，您将被引导到欢迎服务程序。
Servlet 中的sendRedirect()方法
原文：https://www.studytonight.com/servlet/sendredirect-method.php
sendRedirect()方法将响应重定向到另一个资源。这个方法实际上让客户端(浏览器)创建一个新的请求来访问资源。客户端可以在浏览器中看到新的网址。
sendRedirect() 接受相对的 URL ，可以去找服务器内部或者外部的资源。
Servlet: sendRedirect()和RequestDispatcher
一个重定向和一个请求调度的主要区别在于，重定向使客户端(浏览器)创建一个新的请求来获取资源，用户可以在请求调度获取同一请求中的资源时看到新的 URL，而 URL 不变。
另外，另一个非常重要的区别是，sendRedirect()作用于响应对象，而 request dispatch 作用于请求对象。
演示sendRedirect()用法的示例
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
response.sendRedirect("https://www.studytonight.com");
}
finally {
out.close();
}
}
}
forward()和sendRedirect()的区别
| 向前() | 发送重定向() |
| 它在服务器端工作。 | 它在客户端工作。 |
| 它总是发送相同的请求和响应对象。 | 它总是发送新的对象请求。 |
| 它只在服务器内部工作。 | 它在服务器内部和外部都能工作。 |
| 在这种方法中，所有的处理都由 web 容器内部处理。 | 在这个方法中，所有的处理都由另一个 servlet 处理。 |
| 它更快。 | 它比较慢。 |
| 使用 forward()方法可以在地址栏中看到地址。 | 使用 forward()方法在地址栏中看不到地址。 |
| RequestDispatcher 接口用于声明。 | HttpServletResponse 用于声明。 |
| 在 MVC 设计模式中隐藏直接访问是非常有用的。 | 在 MVC 设计模式中隐藏直接访问是没有用的。 |
| 它重用了对象。 | 它不重用对象。 |
| 示例:request . getrequest dispatcher(" servlet _ 1 ")。转发(请求响应)； | 示例:response . send redirect(" Servlet _ 1 ")； |
ServletConfig接口介绍
当 Web 容器初始化一个 servlet 时，它会为该 servlet 创建一个 ServletConfig 对象。ServletConfig 对象用于在初始化期间通过从 web.xml (部署描述符)获取配置信息，将信息传递给 servlet。
ServletConfig 的方法
- 字符串
getInitParameter(String name):返回一个字符串值初始化参数，如果该参数不存在，则返回空值。 - 枚举
getInitParameterNames():返回 servlet 初始化参数的名称，作为字符串对象的枚举，如果 servlet 没有初始化参数，则返回空枚举。 - ServletContext
getServletContext():返回对 ServletContext 的引用 - 字符串
getServletName():返回 servlet 实例的名称
如何在 web.xml 中初始化一个 Servlet
在部署描述符(web.xml)文件中，
或者，在 Servlet 类内部，使用以下代码，
ServletConfig **sc** = getServletConfig();
out.println(sc.**getInitParameter**("email"));
演示 ServletConfig 用法的示例
web.xml
<web-app...>
<servlet>
<servlet-name>check</servlet-name>
<servlet-class>MyServlet</servlet-class>
<init-param>
<param-name>email</param-name>
<param-value>we@studytonight.com</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>check</servlet-name>
<url-pattern>/check</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
MyServlet 类:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
ServletConfig sc = getServletConfig();
out.println(sc.getInitParameter("email"));
}
}
Servlet 中的ServletContext接口
对于每一个网络应用****ServletContext对象都是由网络容器创建的。ServletContext 对象用于从部署描述符 (web.xml)中获取配置信息，该信息可用于作为 web 应用一部分的任何 servlet 或 JSP。
ServletContext的一些重要方法
| 方法 | 描述 |
| 对象getAttribute(String name) | 返回给定名称的容器属性，如果没有该名称的属性，则返回空值。 |
| 弦getInitParameter(String name) | 返回指定参数名称的参数值，如果参数不存在，则返回空值 |
| 枚举getInitParameterNames() | 以字符串对象枚举的形式返回上下文初始化参数的名称 |
| 作废setAttribute(String name,Object obj) | 在应用范围内设置具有给定属性名的对象 |
| 作废removeAttribute(String name) | 从应用上下文中移除具有指定名称的属性 |
如何在 web.xml 中初始化上下文参数
如何获取 ServletContext 的对象
ServletContext app = getServletContext();
*OR*
ServletContext app = getServletConfig().getServletContext();
ServletContext 的优势
- 提供 servlets 之间的通信
- 适用于作为 web 应用一部分的所有 servlets 和 JSP
- 用于从 web.xml 获取配置信息
上下文初始化参数和 Servlet 初始化参数的区别
| 上下文初始化参数 | Servlet 初始化参数 |
| 可用于作为 web 一部分的所有 servlets 和 JSP | 仅适用于为其配置了
| 上下文初始化参数在<web-app>内初始化，而不是在特定的<servlet>元素内初始化 | 在每个特定 servlet 的<servlet>中初始化。 |
| ServletContext 对象用于获取上下文初始化参数 | ServletConfig 对象用于获取 Servlet Init 参数 |
| 整个 web 应用只有一个 ServletContext 对象 | 每个 servlet 都有自己的 ServletConfig 对象 |
演示 ServletContext 用法的示例
web.xml
<web-app ...>
<context-param>
<param-name>driverName</param-name>
<param-value>sun.jdbc.JdbcOdbcDriver</param-value>
</context-param>
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
MyServlet 类:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
ServletContext sc = getServletContext();
out.println(sc.getInitParameter("driverName"));
}
}
Servlet：属性介绍
属性是用于在网络应用中共享信息的对象。属性允许 Servlets 之间共享信息。可以从以下范围之一设置和获取属性:
- 请求
- 会议
- 应用
Servlet:如何设置属性
public void setAttribute(String name, Object obj)方法用于设置属性。
设置属性演示示例
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class First extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
ServletContext sc = getServletContext();
sc.setAttribute("user","Abhijit"); //setting attribute on context scope
}
}
Servlet:如何获取属性
Object getAttribute(String name)方法用于获取属性。
演示获取集合属性值的示例
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Second extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
ServletContext sc = getServletContext();
String str = sc.getAttribute("user"); //getting attribute from context scope
out.println("Welcome"+str); // Prints : Welcome Abhijit
}
}
高级
在 Servlets 中管理会话
原文：https://www.studytonight.com/servlet/session-management.php
我们都知道 HTTP 是无状态协议。所有请求和响应都是独立的。但是有时您需要跟踪客户在多个请求中的活动。例如，当一个用户登录到你的网站时，不管他登录后访问了哪个网页，他的凭证都会在服务器上，直到他注销。这是通过创建一个会话来管理的。
会话管理是网络容器用来存储特定用户的会话信息的机制。Servlet 应用使用四种不同的技术进行会话管理。它们如下:
- 饼干
- 隐藏表单域
- 网址改写
- http session
会话用于存储从客户端发出的所有请求中我们可以从客户端获得的所有内容。
会话如何工作
session 背后的基本概念是，每当用户开始使用我们的应用时，我们可以在整个应用中可用的对象中保存关于他的唯一标识信息，直到它被销毁。因此，无论用户去哪里，我们都将始终拥有他的信息，并且我们始终可以管理哪个用户在做什么。每当用户想要退出您的应用时，用他的信息销毁该对象。
Servlet：什么是HttpSession？
HttpSession 对象用于存储与特定客户端的整个会话。我们可以存储，检索和删除对象的属性。任何 servlet 都可以通过HttpServRequest对象的getSession()方法访问 HttpSession 对象。
servlet:HttpSession 如何工作
- 根据客户端的第一个请求，网络容器生成一个唯一的会话标识，并将其作为响应返回给客户端。这是由 web 容器创建的临时会话。
- 客户端随每个请求发回会话标识。使得 web 容器更容易识别请求来自哪里。
- 网络容器使用该标识，找到与该标识匹配的会话，并将该会话与请求相关联。
Servlet: HttpSession 接口
Servlet HttpSession 的一些重要方法
| 方法 | 描述 |
| 长getCreationTime() | 返回会话创建的时间，以毫秒为单位，自 1970 年 1 月 1 日午夜开始计算。 |
| 弦getId() | 返回包含分配给会话的唯一标识符的字符串。 |
| 长getLastAccessedTime() | 返回客户端上次发送与会话相关联的请求的时间 |
| int getMaxInactiveInterval() | 返回最大时间间隔，以秒为单位。 |
| 作废invalidate() | 破坏会话 |
| 布尔值 isNew() | 如果会话是新的，则返回 true 否则返回 false |
| 作废setMaxInactiveInterval(int interval) | 指定 servlet 容器将使会话无效的时间，以秒为单位。 |
演示 HttpSession 用法的完整示例
下面提到的所有文件都是示例所必需的。
index.html
<form method="post" action="Validate">
User: <input type="text" name="user" /><br/>
Password: <input type="text" name="pass" ><br/>
<input type="submit" value="submit">
</form>
web.xml
<web-app..>
<servlet>
<servlet-name>Validate</servlet-name>
<servlet-class>Validate</servlet-class>
</servlet>
<servlet>
<servlet-name>Welcome</servlet-name>
<servlet-class>Welcome</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Validate</servlet-name>
<url-pattern>/Validate</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>Welcome</servlet-name>
<url-pattern>/Welcome</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
Validate.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Validate extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
String name = request.getParameter("user");
String pass = request.getParameter("pass");
if(pass.equals("1234"))
{
//creating a session
HttpSession session = request.getSession();
session.setAttribute("user", name);
response.sendRedirect("Welcome");
}
}
}
Welcome.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Welcome extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
HttpSession session = request.getSession();
String user = (String)session.getAttribute("user");
out.println("Hello "+user);
}
}
在 Servlet 中将 Cookies 用于会话管理
原文：https://www.studytonight.com/servlet/storing-session-using-cookies.php
cookie是作为响应从网络服务器发送到客户端的小信息。cookie是用于存储客户端状态的最简单的技术。
cookie存储在客户端计算机上。它们有一个生命周期，并在生命周期结束时被客户端浏览器销毁。
然而，使用 Cookies 存储客户端状态有一个缺点，如果客户端已经转而在浏览器中保存 COokie 设置，那么客户端状态将永远无法保存，因为浏览器不允许应用存储 cookies。
servlet:Cookies API
Cookie 是使用 Servlet API 中的 Cookie 类创建的。使用addCookie()方法将饼干添加到响应对象。此方法通过 HTTP 响应流发送 cookie 信息。getCookies()方法用于访问添加到响应对象的 cookies。
示例演示了 Cookies 的用法
以下提到的文件是示例所必需的:
index.html
<form method="post" action="validate">
Name:<input type="text" name="user" /><br/>
Password:<input type="text" name="pass" ><br/>
<input type="submit" value="submit">
</form>
web.xml
<web-app...>
<servlet>
<servlet-name>validate</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>validate</servlet-name>
<url-pattern>/validate</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>First</servlet-name>
<servlet-class>First</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>First</servlet-name>
<url-pattern>/First</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
MyServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
String name = request.getParameter("user");
String pass = request.getParameter("pass");
if(pass.equals("1234"))
{
Cookie ck = new Cookie("username", name);
response.addCookie(ck);
response.sendRedirect("First");
}
}
}
First.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class First extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
Cookie[] cks = request.getCookies();
out.println("Welcome "+ cks[0].getValue());
}
}
饼干的种类
饼干有两种。它们如下:
- 会议
- 坚持的
1)会话 cookie:
会话 cookies 没有任何过期时间。它存在于浏览器内存中。当网络浏览器关闭时，cookies 会自动销毁。
2)持续饼干:
持久 cookies 有一个过期时间。它存储在用户的硬盘中，并根据到期时间销毁。
饼干是如何工作的？
当用户启动一个网站并向网站请求信息时。网站服务器回复并发送一个 cookie。这块饼干放在硬盘上。下次当你回到同一个网站时，你的电脑会把 cookies 发回来。现在，网站服务器识别数据，并将您的信息出售给其他卖家。
演示 5.html
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<form action="abc" method="post">
Enter User name: <input type="text" name="val1"><br>
Enter Password: <input type="text" name="val2"><br>
<input type="submit" value="go">
</form>
</body>
</html>
cookie1.html
package com.app.studytonight;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class cookie1 extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response){
try{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String n=request.getParameter("val1");
out.print("Welcome "+n);
Cookie ck=new Cookie("uname",n);
response.addCookie(ck);
out.print("<form action='pqr' method='post'>");
out.print("<input type='submit' value='go'>");
out.print("</form>");
out.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}
cookie2.html
package com.app.studytonight;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class cookie2 extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response){
try{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
Cookie ck[]=request.getCookies();
out.print("Hello "+ck[0].getValue());
out.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}
web.xml
<servlet>
<servlet-name>s1</servlet-name>
<servlet-class>com.app.studytonight.cookie1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>s1</servlet-name>
<url-pattern>/abc</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>s2</servlet-name>
<servlet-class>com.app.studytonight.cookie1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>s2</servlet-name>
<url-pattern>/pqr</url-pattern>
</servlet-mapping>
</web-app>
在 Servlet 中使用 URL 重写进行会话管理
原文：https://www.studytonight.com/servlet/url-rewriting-for-session-management.php
如果客户端在浏览器中禁用了 cookie，那么使用 cookie 的会话管理将不起作用。在这种情况下 URL 重写可以作为备份。网址改写将永远有效。
在 URL 重写中，会在 URL 的末尾添加一个标记(参数)。令牌由用equal(=)符号分隔名称/值对组成。
例如:
当用户点击有参数的网址时，请求会进入网页容器，在网址的末尾有额外的信息。网络容器将获取请求的网址的额外部分，并将其用于会话管理。
getParameter()方法用于获取服务器端的参数值。
演示网址重写用法的示例
以下提到的文件是示例所必需的:
index.html
<form method="post" action="validate">
Name:<input type="text" name="user" /><br/>
Password:<input type="text" name="pass" ><br/>
<input type="submit" value="submit">
</form>
web.xml
<web-app...>
<servlet>
<servlet-name>validate</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>validate</servlet-name>
<url-pattern>/validate</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>First</servlet-name>
<servlet-class>First</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>First</servlet-name>
<url-pattern>/First</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
MyServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
String name = request.getParameter("user");
String pass = request.getParameter("pass");
if(pass.equals("1234"))
{
response.sendRedirect("First?user_name="+ name);
}
}
}
First.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class First extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String user = request.getParameter("user_name");
out.println("Welcome "+user);
}
}
在 Servlet 中将隐藏表单字段用于会话管理
原文：https://www.studytonight.com/servlet/hidden-form-field.php
隐藏的表单字段也可用于存储特定客户端的会话信息。在隐藏表单字段的情况下，隐藏字段用于存储客户端状态。在这种情况下，用户信息存储在隐藏字段值中，并从另一个 servlet 中检索。
使用隐藏表单域进行会话管理的优势
- cookie 是否被禁用并不取决于浏览器。
- 需要插入隐藏类型的简单 HTML 输入字段。因此，它更容易实现。
使用隐藏表单字段进行会话管理的缺点
- 每一页都需要额外的表格提交。这是很大的开销。
演示会话隐藏表单字段用法的示例
以下提到的文件是示例所必需的:
index.html
<form method="post" action="validate">
Name:<input type="text" name="user" /><br/>
Password:<input type="text" name="pass" ><br/>
<input type="submit" value="submit">
</form>
web.xml
<web-app...>
<servlet>
<servlet-name>First</servlet-name>
<servlet-class>First</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>First</servlet-name>
<url-pattern>/First</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>Second</servlet-name>
<servlet-class>Second</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Second</servlet-name>
<url-pattern>/Second</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
First.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class First extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
//getting value submitted in form from HTML file
String user = request.getParameter("user");
//creating a new hidden form field
out.println("<form action='Second'>");
out.println("<input type='hidden' name='user' value='"+user+"'>");
out.println("<input type='submit' value='submit' >");
out.println("</form>");
}
}
Second.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Second extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
//getting parameter from the hidden field
String user = request.getParameter("user");
out.println("Welcome "+user);
}
}
就像我们在第一个 Servlet 中创建了一个隐藏字段，填充了用户的值，并发送给了第二个 Servlet，现在第二个 Servlet 也有了用户信息。同样，我们将不得不使用隐藏字段在任何需要的地方发送这些信息。
Servlet 中的ServletContextEvent和ServletContextListener
原文：https://www.studytonight.com/servlet/servlet-context-listener.php
ServletContextEvent 类给出关于 web 应用的 servlet 上下文变化的通知。 ServletContextListener 接收关于 servlet 上下文更改的通知，并执行一些操作。ServletContextListener 用于在初始化和销毁上下文时执行重要任务。简而言之，ServletContextEvent 和 ServletContextListener 成对工作，每当 Servlet 上下文发生变化时，ServletContextEvent 都会发布一个通知，由 ServletContextListener 接收，然后根据该通知执行某些任务。
ServletContextListener 接口的方法
| 方法 | 描述 |
| 作废contextDestroyed(ServletContextEvent e) | 在应用被销毁时调用。 |
| 作废contextInitialized(ServletContextEvent e) | 在应用初始化时调用。 |
制作和使用上下文监听器
上下文监听器不是 servlet 或者 JSP，它是一个实现 ServletContextListener 接口的类，提供contextDestroyed()和contextInitialized()的定义。
演示 servletcontextlistener 用法的示例
index.html
<a href="**Counter**">Total Page views</a>
web.xml
在这个例子中，我们将不得不创建一个名为计数器的表，该表有一个名为页面视图的列来保存页面视图的数量。
mylister . Java
import java.sql.*;
import javax.servlet.*;
public class MyListener implements ServletContextListener
{
ServletContext ctx;
Connection con;
Statement s;
PreparedStatement ps;
ResultSet rs;
int count;
public void contextInitialized(ServletContextEvent sce) {
try {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","user","password");
s = con.createStatement();
// fetching pageviews value from table counter
rs = s.executeQuery("select pageview from counter");
while(rs.next()) {
count = rs.getInt(1);
}
ctx = sce.getServletContext();
ctx.setAttribute("pcount", count);
}
catch(Exception e) {
e.printStackTrace();
}
}
public void contextDestroyed(ServletContextEvent sce) {
try
{
ctx = sce.getServletContext();
count = (Integer)ctx.getAttribute("pcount");
ps = con.prepareStatement("update counter set pcount='"+count+"'");
ps.executeUpdate();
}
catch(Exception e) {
e.printStackTrace();
}
}
}
Counter.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Counter extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
ServletContext ctx = getServletContext();
Integer count = (Integer)ctx.getAttribute("pcount");
out.println(count+": pageview");
ctx.setAttribute("pcount", ++count);
}
}
什么是ServletRequestAttributeEvent？
原文：https://www.studytonight.com/servlet/attribute-listener.php
ServletRequestAttributeEvent类给出应用中 ServletRequest 属性更改的通知。
这个类监听通知，并在请求属性发生任何变化时执行一些重要任务。
ServletRequestAttributeListener 的一些重要方法
| 方法 | 描述 |
| 作废attributeAdded(ServletRequestAttributeEvent e) | 通知向 servlet 请求添加了新属性。 |
| 作废attributeRemoved(ServletRequestAttributeEvent e) | 通知现有属性已从 servlet 请求中删除。 |
| 作废attributeReplaced(ServletRequestAttributeEvent e) | servlet 请求中的属性被替换的通知 |
什么是 ServletContextAttributeEvent？
ServletContextAttributeEvent类让您知道 web 应用上下文中的属性是否已被添加、移除或替换。
实现 ServletContextAttributeListener 接口，接收 web 应用 servlet 上下文中属性列表更改的通知。
ServletContextAttributeListener 的一些重要方法
| 方法 | 描述 |
| 作废attributeAdded(ServletContextAttributeEvent e) | 向上下文添加了新属性的通知。 |
| 作废attributeRemoved(ServletContextAttributeEvent e) | 通知现有属性已从上下文中删除。 |
| 作废attributeReplaced(ServletContextAttributeEvent e) | 通知上下文中的属性已被替换 |
Servlet：HttpSessionEvent和HttpSessionListener
原文：https://www.studytonight.com/servlet/httpsession-event-and-listener.php
HttpSessionEvent 类为 web 应用内的会话更改提供通知。httpessionlistener接收 web 应用中活动会话列表的更改通知，并执行一些操作。HttpSessionListener 用于在创建或销毁会话时执行一些重要任务。例如:计算活动会话的数量。
Servlet:其他一些与会话相关的监听器
| 听众 | 描述 |
| http session activationlistener | 让您知道会话何时从一台虚拟机移动到另一台虚拟机。 |
| https 会话绑定侦听器 | 您的属性类对象在会话中被添加或删除时会得到通知。 |
| http session attribute listener | 让您知道在会话中何时添加、删除或替换任何属性。 |
HttpSessionListener 的方法
| 方法 | 描述 |
| 作废sessioC(n, r)eated(HttpSessionEvent e) | 会话已创建的通知。 |
| 作废sessionDestroyed(HttpSessioEvent e) | 会话被破坏的通知。 |
HttpSessionListener 示例
在本例中，我们将创建一个会话侦听器，它将计算 web 应用中活动会话的数量。
MySessionCounter.java
import javax.servlet.http.*;
public class MySessionCounter implements HttpSessionListener {
private static int sessionCount;
public int getActiveSession()
{
return sessionCount;
}
public void sessio`C(n, r)`eated(HttpSessionEvent e)
{
sessionCount++;
}
public void sessionDestroyed(HttpSessionEvent e)
{
sessionCount--;
}
}
web.xml
<web-app ...>
<listener>
<listener-class>MySessionCounter</listener-class>
</listener>
</web-app>
Servlet 中的ServletRequestEvent和ServletRequestListener
原文：https://www.studytonight.com/servlet/servlet-request-event-and-listener.php
ServletRequestEvent 类为 ServletRequest 提供生命周期事件的通知。事件的来源是网络应用的 ServletContext。 ServletRequestListener 接收 ServletRequestEvent 生成的通知，并根据这些通知执行一些指定的任务。
ServletRequestListener 的几个重要方法
| 方法 | 描述 |
| 作废requestDestroyed(ServletRequestEvent e) | 当请求即将超出 web 应用的范围时调用.. |
| 作废requestInitialized(ServletRequestEvent e) | 当请求即将进入 web 应用的范围时调用。 |
ServletRequestListener 示例
因此，可以很容易地实现 ServletRequestListener 接口，并为它提供的两个方法requestDestroyed()和requestInitialized()提供定义。
顾名思义，这些方法将在请求被初始化和销毁时被调用，因此我们可以将它们用于各种目的，比如当请求被销毁时变量清理，或者当请求被接收时执行一些初始检查等等。
Servlet：过滤器 API 简介
过滤器是您可以使用和配置来执行一些过滤任务的组件。过滤器用于请求的预处理和响应的后处理。您可以使用任意数量的过滤器对请求进行预处理，对响应进行后处理。过滤器在 web 应用的部署描述符中配置。
Servlet:过滤器是如何工作的？
- 当请求到达网络容器时，它会检查是否有任何过滤器具有与请求的网址相匹配的网址模式。
- 网络容器使用匹配的网址模式定位第一个过滤器，并执行过滤器的代码。
- 如果另一个过滤器有匹配的网址模式，那么它的代码就会被执行。这种情况一直持续到没有匹配网址模式的过滤器。
- 如果没有错误发生，请求将传递给目标 servlet。因此，我们知道，只有当所有相关的过滤器成功执行时，请求才会被传递给目标 servlet。
- servlet 将响应返回给调用者。应用于请求的最后一个筛选器是应用于响应的第一个筛选器。
- 最后，响应将被传递到网络容器，该容器将其传递给客户端。
Servlet:关于过滤器 API 的更多信息
过滤 API 是 Servlet API 的一部分。过滤器接口在 javax.servlet 包中找到。
为了创建过滤器，我们必须实现过滤器接口。过滤器接口为过滤器提供了以下生命周期方法:
- void
init(FilterConfig filterConfig):由 web 容器调用，向过滤器指示它正在投入使用。 - voiddoFilter(servlet request，ServletResponse response，FilterChain chain) :由于客户端请求链末端的资源，每次请求/响应对通过链时，由容器调用。
- void
destroy():由 web 容器调用，向过滤器指示它正在停止服务。
Servlet:什么是 FilterChain 接口？
FilterChain 对象用于调用链中的下一个过滤器，或者如果调用过滤器是链中的最后一个过滤器，则调用链末端的 rosource。过滤器链末端的资源可以是目标 Servlet(在请求流的情况下)或客户机(在响应流的情况下)，如上图所示。
在部署描述符中声明一个 Servlet 过滤器
演示 Servlet 过滤器使用的示例
在本例中，我们使用过滤器进行身份验证(检查正确的用户名和密码)。这里index.html会向用户询问用户名和密码，我的过滤器会验证用户输入的密码，如果用户输入了“1234”作为密码，那么他会先被转发到的 servlet，否则 index.html 会再次显示给用户。
这正是我们之前使用两个 servlet 类所做的，一个用于验证，另一个用于欢迎用户。现在我们将插入一个过滤器来验证用户。
index.html
<form method="post" action="first">
Name:<input type="text" name="user" /><br/>
Password:<input type="text" name="pass" /><br/>
<input type="submit" value="submit" />
</form>
web.xml
<web-app..>
<filter>
<filter-name>MyFilter</filter-name>
<filter-class>MyFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>MyFilter</filter-name>
<servlet-name>first</servlet-name>
</filter-mapping>
<servlet>
<servlet-name>first</servlet-name>
<servlet-class>first</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>first</servlet-name>
<url-pattern>/first</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
MyFilter.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyFilter implements Filter {
public void init(FilterConfig fc) throws ServletException {}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
PrintWriter out = response.getWriter();
String pass = request.getParameter("pass");
if(pass.equals("1234"))
{
chain.doFilter(request, response);
}
else
{
out.println("You have enter a wrong password");
RequestDispatcher rs = request.getRequestDispatcher("index.html");
rs.include(request, response);
}
}
public void destroy() { }
}
first.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class first extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String user = request.getParameter("user");
out.println("Wellcome " + user);
}
}
JSP
JSP 的基础
JSP 简介
JSP 技术用于创建动态 web 应用。 JSP 页面比 Servlet 更容易维护。JSP 页面与 servlet 相反，因为 servlet 在 Java 代码内部添加 HTML 代码，而 JSP 使用 JSP 标签在 HTML 内部添加 Java 代码。一个 Servlet 能做的一切，一个 JSP 页面也能做到。
JSP 使我们能够编写包含标签的 HTML 页面，在其中我们可以包含强大的 Java 程序。使用 JSP，可以很容易地将 Presentation 和 Business 逻辑分开因为 web 设计人员可以设计和更新 JSP 页面，从而创建表示层，java 开发人员可以编写服务器端复杂的计算代码，而无需考虑 web 设计。并且这两层都可以通过 HTTP 请求轻松交互。
最终，一个 JSP 变成了一个 Servlet
JSP 页面被 Web 容器转换成 Servlet 。容器将 JSP 页面翻译成 servlet 类源(。java) 文件，然后编译成一个 Java Servlet 类。
为什么 JSP 优先于 servlets？
- JSP 提供了一种更简单的方法来编码动态网页。
- JSP 不需要额外的文件，如 java 类文件、web.xml 等
- JSP 代码中的任何更改都由 Web 容器(像 tomcat 这样的应用服务器)处理，不需要重新编译。
- JSP 页面可以直接访问，不像 servlets 那样需要 web.xml 映射。
JSP 的优势
- 易于维护和编码。
- 高性能和可扩展性。
- JSP 是基于 Java 技术构建的，所以是平台无关的。
JSP 的生命周期
为了服务请求，一个 JSP 页面被转换成 Servlet。JSP 页面到 Servlet 的转换称为 JSP 的生命周期。JSP 生命周期与 Servlet 生命周期完全相同，只是多了一个第一步，即将 JSP 代码翻译成 Servlet 代码。以下是 JSP 生命周期步骤:
- JSP 到 Servlet 代码的翻译。
- 将 Servlet 编译成字节码。
- 正在加载 Servlet 类。
- 正在创建 servlet 实例。
- 通过调用
jspInit()方法初始化 - 通过调用
_jspService()方法进行请求处理 - 调用
jspDestroy()方法销毁
Web 容器将 JSP 代码翻译成一个 servlet 类源(。java)文件，然后将其编译成 java servlet 类。第三步，使用 classloader 加载 servlet 类字节码。容器然后创建该 servlet 类的一个实例。
*初始化的 servlet 现在可以服务请求。对于每个请求，网络容器调用 _jspService() 方法。当容器从服务中移除 servlet 实例时，它调用jspdestory()方法来执行任何需要的清理。
当 JSP 被翻译成 Servlet 时会发生什么
让我们看看当 JSP 代码被翻译成 Servlet 时会发生什么。里面写的代码是 JSP 代码。
<html>
<head>
<title>My First JSP Page</title>
</head>
<%
int count = 0;
%>
<body>
Page Count is:
<% out.println(++count); %>
</body>
</html>
上面的 JSP 页面(hello.jsp)变成了这个 Servlet，
public class hello_jsp extends HttpServlet
{
public void _jspService(*HttpServletRequest* request, *HttpServletResponse* response)
throws IOException,ServletException
{
PrintWriter out = response.getWriter();
response.setContenType("text/html");
out.write("<html><body>");
int count=0;
out.write("Page count is:");
out.print(++count);
out.write("</body></html>");
}
}
这只是为了解释，内部发生了什么。作为一名 JSP 开发人员，您不必担心 JSP 页面如何转换成 Servlet，因为它是由 web 容器自动完成的。
创建一个 JSP 页面
一个 JSP 页面看起来类似于一个 HTML 页面，但是一个 JSP 页面也有 Java 代码在里面。我们可以使用以 and ends with %>开头的**脚本标签**将任何常规的 Java 代码放入 JSP 文件中。JSP 页面用于开发动态响应。
学习 HTML，去 HTML 互动课程边学习 HTML 边并排练习。
在 Eclipse 中创建 JSP 页面的示例
- 打开 Eclipse，点击新建→动态网页项目
- 为您的项目命名，然后单击“确定”
- 您将看到在项目资源管理器中创建了一个新项目
- 要创建新的 JSP 文件，右键单击网页内容目录，新建→ JSP 文件
- 为您的 JSP 文件命名，然后单击“完成”。
- 在你的 JSP 文件中写一些东西。完整的 HTML 和 JSP 代码放在
<body>标签里面，就像 HTML 页面一样。
- 要运行您的项目，右键单击项目，选择运行方式→在服务器上运行
- 要启动服务器，请选择现有服务器名称，然后单击“完成”
- 在浏览器中查看输出。
*
JSP 脚本元素
原文：https://www.studytonight.com/jsp/jsp-scripting-element.php
JSP 脚本元素写在标签里面。在 JSP 页面翻译期间，标签中的这些代码由 JSP 引擎处理。JSP 页面中的任何其他文本都被视为 HTML 代码或纯文本。``
``示例:
<html>
<head>
<title>My First JSP Page</title>
</head>
<%
int count = 0;
%>
<body>
Page Count is <% out.println(++count); %>
</body>
</html>
为了实验，试着从上面的代码中移除脚本标签，并将其作为 JSP 运行。您将看到所有内容都是按浏览器上的原样打印的，因为没有脚本标签，所有内容都被认为是普通的 HTML 代码。
`* * *
有五种不同类型的脚本元素
| 脚本元素 | 例子 |
| comment | |
| 指令 | |
| 申报 | |
| 脚本 | |
| 表达式 | |
JSP Comment
当你正在创建一个 JSP 页面，并且想要对你正在做的事情进行评论时，使用 JSP 注释。JSP 注释只在 JSP 页面中看到。这些注释在翻译阶段不包含在 servlet 源代码中，也不会出现在 HTTP 响应中。JSP 注释的语法如下:
<%-- JSP comment --%>
JSP 评论简单示例
<html>
<head>
<title>My First JSP Page</title>
</head>
<%
int count = 0;
%>
<body>
Page Count is <% out.println(++count); %>
</body>
</html>
注意:在代码中添加注释被认为是编程界的一个好做法。
- *```
JSP 脚本标签
Scriptlet 标签允许您在 JSP 页面中编写 java 代码。Scriptlet 标签通过编写脚本/java 代码来实现_jspService方法功能。Scriptlet 标记的语法如下:
<% JAVA CODE %>
JSP:script let 示例
在这个例子中，我们将显示页面访问量。
<html>
<head>
<title>My First JSP Page</title>
</head>
<%
int count = 0;
%>
<body>
Page Count is <% out.println(++count); %>
</body>
</html>
自从上几课以来，我们一直在使用上面的例子，在这个脚本中使用了标签。scriptlet 标签中编写的所有内容都被编译为 java 代码。就像上面的例子一样，我们用值 0 初始化类型为int的count变量。然后我们一边打印一边用++算子对其进行加法运算。
JSP 使得直接从 HTML 代码中执行计算、数据库交互等变得非常容易。只需在 scriptlet 标签中编写 java 代码。
JSP 脚本标签示例
在这个例子中，我们将创建一个简单的 JSP 页面，从请求参数中检索用户名。index.html页面将从用户处获取用户名。
index.html
<form method="**POST**" action="**welcome.jsp**">
Name <input type="text" name="*user*" >
<input type="submit" value="Submit">
</form>
在上面的 HTML 文件中，我们创建了一个表单，其中有一个供用户输入姓名的输入文本字段，以及一个提交表单的提交按钮。在提交时，会向 welcome.jsp 文件(action="**welcome.jsp**")发出一个 HTTP Post 请求(method="**POST**")，并带有表单值。
welcome.jsp
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Welcome Page</title>
</head>
<%
String user = request.getParameter("user");
%>
<body>
Hello, <% out.println(user); %>
</body>
</html>
我们知道，一个 JSP 代码被翻译成 Servlet 代码，在其中执行_jspService方法，该方法以 HttpServletRequest 和 HttpServletResponse 为参数。所以在welcome.jsp文件中，请求是 HTTP Request，它有从 index.html 页面的表单发送的所有参数，我们可以很容易地用参数名为参数的getParameter()来获取它的值。
混合脚本标签和超文本标记语言
让我们通过几个例子来看看如何利用 JSP 脚本和 HTML 的力量来构建动态网页。
如果我们想用 HTML 创建一个包含一些动态数据的表，例如从一些 MySQL 表或文件中读取数据。怎么做？这里我们将通过创建一个从 1 到 n 的表来描述这种技术。
<table border = 1>
**for ( int i = 0; i < n; i++ ) {
**%>**
<tr>
<td>Number</td>
<td></td>
</tr>
**}
**%>**
</table>****
上面这段代码将进入 JSP 文件的<body>标签，当你用某个值初始化n时，它将会工作。
此外，观察者紧密观察我们只在 scriptlet 标签中包含了 java 代码，所有的 HTML 部分都在它之外。同样，我们可以做很多事情。
这里还有一个非常简单的例子:
**if ( hello ) {
**%>**
<p>Hello, world</p>
**} else {
**%>**
<p>Goodbye, world</p>
**}
**%>********
上面的代码使用 if-else 条件，基于名为hello的布尔变量的值来计算要显示的内容。
您甚至可以要求用户使用 HTML 表单输入hello的值，并基于此评估您的 JSP 代码。
JSP 声明标签
我们知道，在最后，一个 JSP 页面被翻译成 Servlet 类。所以当我们在声明标签内部的 JSP 中声明一个变量或方法时，这意味着声明是在 Servlet 类内部而不是在服务(或任何其他)方法外部进行的。您可以在声明标签中声明静态成员、实例变量和方法。声明标记的语法:
<%! declaration %>
声明标签示例
<html>
<head>
<title>My First JSP Page</title>
</head>
<%!
int count = 0;
%>
<body>
Page Count is:
<% out.println(++count); %>
</body>
</html>
在上面的代码中，我们已经使用了声明标签来声明变量count。上面的 JSP 页面变成了这个 Servlet:
public class hello_jsp extends HttpServlet
{
**int count=0;**
public void **_jspService**(HttpServletRequest request, HttpServletResponse response)
throws IOException,ServletException
{
PrintWriter out = response.getWriter();
response.setContenType("text/html");
out.write("<html><body>");
out.write("Page count is:");
out.print(++count);
out.write("</body></html>");
}
}
在上面的 servlet 中，我们可以看到变量count是在_jspservice()方法之外声明的。如果我们使用 scriptlet 标记声明同一个变量，它将出现在服务方法中，如上一课所示。
何时使用声明标签而不是脚本标签
如果你想在你的 JSP 文件中包含任何方法，那么你必须使用声明标签，因为在 JSP 的翻译阶段，声明标签中的方法和变量变成了实例方法和实例变量，并且也被赋予了默认值。
例如:
<html>
<head>
<title>My First JSP Page</title>
</head>
<%!
int *count* = 0;
int **getCount**() {
System.out.println( "In getCount() method" );
return count;
}
%>
<body>
Page Count is:
<% out.println(getCount()); %>
</body>
</html>
上述代码将被翻译成以下 servlet:
public class hello_jsp extends HttpServlet
{
**int count = 0;**
int **getCount**() {
System.out.println( "In getCount() method" );
return count;
}
public void **_jspService**(HttpServletRequest request, HttpServletResponse response)
throws IOException,ServletException
{
PrintWriter out = response.getWriter();
response.setContenType("text/html");
out.write("<html><body>");
out.write("Page count is:");
out.print(*getCount()*);
out.write("</body></html>");
}
}
然而，我们在 scriptlet 标签中添加的任何内容都在_jspservice()方法中，因此我们不能在 scriptlet 标签中添加任何函数，因为在编译时，它会尝试在服务方法中创建一个函数getCount()，而在 Java 中，方法中的方法是不允许的。
JSP 指令标签
指令标签在页面翻译时给 Web 容器特殊指令。指令标签有三种类型:页面，包括和标签库。
| 管理的 | 描述 |
| <%@ page ... %> | 定义页面相关属性，如语言、会话、错误页面等。 |
| <%@ include ... %> | 定义要包含的文件。 |
| <%@ taglib ... %> | 声明页面中使用的标记库 |
稍后我们将讨论包括和塔格利布指令。您可以将 page 指令放在 JSP 文件中的任何地方，但是最好将其作为 JSP 页面的第一条语句。
页面指令定义了许多在翻译时与网络容器通信的页面相关属性。使用页面指令的基本语法是<%@ page attribute="value" %>，其中属性可以是以下之一:
- 导入属性
- 语言属性
- 扩展属性
- 会话属性
- isThreadSafe 属性
- isErrorPage 属性
- 错误页面属性
- contentType 属性
- 自动刷新属性
- 缓冲属性
导入属性
import 属性定义了必须在 servlet 类定义中导入的一组类和包。例如
or
语言属性
语言属性定义页面中使用的脚本语言。
扩展属性
extends 属性定义了从 JSP 页面生成的 servlet 类的超类的类名。
会话属性
会话属性定义了 JSP 页面是否参与 HTTP 会话。该值为真或假。
isThreadSafe 属性
isThreadSafe 属性声明 JSP 是否是线程安全的。该值为真或假
isErrorPage 属性
isErrorPage 属性声明当前 JSP 页面是否代表另一个 JSP 的错误页面。
错误页面属性
errorPage 属性表示另一个 JSP 页面，它将处理当前 JSP 页面引发的所有运行时异常。它指定另一个页面的 URL 路径，请求将被分派到该页面以处理当前 JSP 页面引发的运行时异常。
contentType 属性
contentType 属性定义了 JSP 响应的 MIME 类型。
自动刷新属性
自动刷新属性定义缓冲输出是否自动刷新。默认值为“真”。
缓冲属性
buffer 属性定义了隐式 out 对象如何处理缓冲。
JSP 表达式标签
表达式标签用于打印出放在标签之间的 java 语言表达式。表达式标签可以保存任何可以用作 out.print() 方法参数的 java 语言表达式。表达式标签的语法
<%= Java Expression %>
当容器看到这个
<%= (2*5) %>
变成这个:
out.print((2*5));
注意:不要在表达式标签中用分号结束表达式。像这样:
<%= (2*5); %>
表达式标签示例
<html>
<head>
<title>My First JSP Page</title>
</head>
<%
int count = 0;
%>
<body>
Page Count is <%= ++count %>
</body>
</html>
JSP 核心
JSP 中的隐式对象
原文：https://www.studytonight.com/jsp/implicit-object-in-jsp.php
JSP 提供了对一些隐式对象访问，这些对象代表了 JSP 页面开发人员可能需要使用的 servlets 的一些常用对象。例如，您可以通过使用 request 变量来检索 HTML 表单参数数据，该变量表示httpersvletrequest对象。
以下是 JSP 隐式对象
| 隐式对象 | 描述 |
| 请求 | 与请求相关联的 HttpServletRequest 对象。 |
| 回应 | 与发送回浏览器的响应相关联的对象。 |
| 出 | 与响应的输出流相关联的 JspWriter 对象。 |
| 会话 | 与给定请求用户的会话相关联的对象。 |
| 应用 | 网络应用的 ServletContext 对象。 |
| 配置 | 与当前 JSP 页面的 servlet 相关联的 ServletConfig 对象。 |
| pageContext | 封装当前 JSP 页面的单个请求的环境的页面上下文对象 |
| 页 | 页面变量相当于这个变量的 Java 编程语言。 |
| 例外 | 异常对象表示由其他 JSP 页面抛出的可抛出对象。 |
所有这些都非常有用，你会慢慢了解它们，因为你会在你的职业生涯中从事直播项目。例如:当你要创建一个必须在用户会话中创建的应用时session将出现，当你在应用中提交表单时使用request等。
稍后我们将详细了解这些内容。
JSP 包含指令
原文：https://www.studytonight.com/jsp/jsp-include-directive.php
include 指令告诉 Web 容器复制包含文件中的所有内容，并将其粘贴到当前的 JSP 文件中。包含指令的语法是:
<%@ include file="filename.jsp" %>
包含指令的示例
welcome.jsp
<html>
<head>
<title>Welcome Page</title>
</head>
<body>
**Welcome, User
</body>
</html>**
**header.jsp
<html>
<body>
<img src="header.jpg" alt="This is Header image" / >
</body>
</html>
*上面的例子展示了一个非常标准的实践。每当我们构建一个网页应用，所有的网页都有相同的顶部导航栏和底部页脚。我们将它们作为单独的 jsp 文件，并在所有页面中使用include指令包含它们。因此，每当我们必须更新顶部导航栏或页脚中的内容时，我们只需在一个地方完成即可。很方便，不是吗？
include指令的另一个标准应用是，如果你创建一个单独的 jsp 文件，带有一些常用的函数，有点像 util jsp 文件。它可以包含在网页中任何你想使用这些功能的地方。
类似地，有许多方法可以证明这个指令在给 web 应用代码提供结构方面非常有用。
JSP Taglib 指令
原文：https://www.studytonight.com/jsp/jsp-taglib-directive.php
taglib 指令用于定义当前 JSP 页面使用的标签库。一个 JSP 页面可能包含几个标签库。JavaServer Pages 标准标签库(JSTL)，是一个有用的 JSP 标签的集合，它提供了许多常用的核心功能。它支持许多一般的结构化任务，例如迭代和条件、用于操作 XML 文档的现成标记、国际化标记以及执行 SQL 操作。taglib 指令的语法是:
<%@ taglib prefix="prefixOfTag" uri="uriOfTagLibrary" %>
前缀用于将自定义标记与其他库自定义标记区分开来。前缀加在自定义标记名称的前面。每个自定义标记都必须有前缀。
URI 是标签库的唯一名称。
你可以给前缀起任何名字，但它应该是唯一的。
JSP:使用 Taglib 指令
要在你的应用中使用 JSTL，你必须在你的网络应用/WEB-INF/lib目录中有jstl.jar。从阿帕奇标准 Taglib 页面下载 jar 文件。
有许多现成的 JST 库可供您使用，让您的生活更加轻松。以下是对不同组的 JST 库的广泛划分:
- 核心标签-URI→http://java.sun.com/jsp/jstl/core
- 格式化标签-URI→http://java.sun.com/jsp/jstl/fmt
- SQL 标记 uri→http://Java . sun . com/JSP/jstl/SQL
- XML 标签-URI→http://java.sun.com/jsp/jstl/xml
- JSTL 函数-URI→http://java.sun.com/jsp/jstl/functions
可以在这里查看完整的 JST 库: Apache 标准 Taglib API
JSP 异常处理
原文：https://www.studytonight.com/jsp/exception-handling-in-jsp.php
异常处理是处理应用中可能出现的异常情况的过程。JSP 中的异常处理比 Java 技术中的异常处理容易得多。尽管 JSP 技术也使用相同的异常类对象。
很明显，你不想向任何浏览你网站的随机用户显示错误栈跟踪。您不能阻止应用中的所有错误，但您至少可以提供一个用户友好的错误响应页面。
在 JSP 中执行异常处理的方法
JSP 提供了 3 种不同方式来执行异常处理:
- 使用页面指令的iserrrpage和 errorPage 属性。
- 使用部署描述符中的 <错误页面> 标签。
- 使用简单的
try...catch块。
isErrorPage 和 ErrorPage 属性的示例
isErrorPagepage 指令中的属性正式指定一个 JSP 页面为错误页面。
error.jsp
页面指令中的errorPage属性通知 Web 容器，如果当前页面出现异常，将请求转发到指定的错误页面。
sum.jsp
每当sum.jsp页面出现异常时，用户会被重定向到error.jsp页面，在那里您可以显示一条漂亮的消息，或者您也可以将异常跟踪打印到后台的文件/数据库中，以便稍后检查是什么导致了错误。
在部署描述符中声明错误页
您也可以在 DD 中为整个 Web 应用声明错误页面。使用部署描述符中的<error-page>标签。您甚至可以为不同的异常类型或 HTTP 错误代码类型(503、500 等)配置不同的错误页面。
声明所有异常类型的错误页面
<error-page>
<exception-type>**java.lang.Throwable**</exception-type>
<location>**/error.jsp**</location>
</error-page>
为更详细的异常声明错误页面
<error-page>
<exception-type>**java.lang.ArithmeticException**</exception-type>
<location>**/error.jsp**</location>
</error-page>
基于 HTTP 状态码声明错误页面
<error-page>
<error-code>404</error-code>
<location>**/error.jsp**</location>
</error-page>
使用尝试...捕捉块
使用try...catch块就像在核心 Java 中使用它一样。
<html>
<head>
<title>Try...Catch Example</title>
</head>
<body>
****try**{
int i = 100;
i = i / 0;
out.println("The answer is " + i);
}
**catch** (Exception *e*){
out.println("An exception occurred: " + *e*.**getMessage()**);
}
**%>**
</body>
</html>**
JSP 标准标签（动作元素）
JSP 规范提供了在 JSP 页面中使用的标准(动作)标签。这些标签用于从您的 JSP 页面中移除或消除 scriptlet 代码，因为现在在技术上不建议使用 script let 代码。将 java 代码直接放在 JSP 页面中被认为是不好的做法。
标准标签以jsp:前缀开头。有许多 JSP 标准动作标签用于执行一些特定的任务。
以下是一些可用的 JSP 标准动作标签:
| 动作标签 | 描述 |
| jsp:forward | 将请求转发到新页面用法:<jsp:forward page="Relative URL" /> |
| jsp:useBean | 实例化一个 JavaBean 用法:<jsp:useBean id="beanId" /> |
| jsp:getProperty | 从 JavaBean 实例中检索属性。用法:
<jsp:useBean id="beanId" ... />
...
<jsp:getProperty name="beanId" property="someProperty" .../>
其中， beanName 是我们想要访问其属性的预定义 bean 的名称。 |
| jsp:setProperty | 将数据存储在任何 JavaBeans 实例的属性中。用法:
<jsp:useBean id="beanId" ... />
...
<jsp:setProperty name="beanId" property="someProperty"
value="some value"/>
其中， beanName 是我们想要访问其属性的预定义 bean 的名称。 |
| jsp:include | 将 JSP 页面的运行时响应包含到当前页面中。 |
| jsp:plugin | 生成特定于客户端浏览器的构造，为 Java 小程序生成一个 OBJECT 或 EMBED 标记 |
| jsp:fallback | 如果 java 插件在客户端不可用，则提供替换文本。如果没有加载包含的 jsp 插件，您可以使用它打印一条消息。 |
| jsp:element | 动态定义 XML 元素 |
| jsp:attribute | 定义动态定义的 XML 元素的属性 |
| jsp:body | 在标准或自定义标签中用于提供标签主体。 |
| jsp:param | 向请求对象添加参数。 |
| jsp:text | 用于在 JSP 页面和文档中编写模板文本。用法:<jsp:text>Template data</jsp:text> |
JSP JavaBean 组件
JavaBeans 组件是一个具有以下特性的 Java 类:
- 无参数构造器。
- 用访问器和变异器(getter 和 setter 方法)定义的属性。
- 类不能定义任何公共实例变量。
- 该类必须实现 java.io.Serializable 接口。
JavaBean 的示例
让我们举一个简单的 Java 代码例子来理解我们所说的 JavaBean 是什么意思，
import java.io.Serializable;
public class StudentBean implements Serializable
{
private String name;
private int roll;
// constructor
public StudentBean()
{
this.name = "";
this.roll = "";
}
// getters and setters
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public int getRoll()
{
return roll;
}
public void setRoll(int roll)
{
this.roll = roll;
}
}
正如您在上面的代码中看到的，JavaBean 只不过是一个实现接口Serializable的 Java 类。
在 JSP 页面中使用 JavaBean
JavaBeans 可以在任何使用<jsp:useBean>标记的 JSP 页面中使用，例如:
<jsp:useBean id="bean name" scope="fully qualified path of bean" typeSpec/>
在 JSP 页面中使用任何 JavaBean 属性
JavaBeans 可以在任何使用 <jsp:useBean> 标记、 <jsp:setProperty> 标记和 <jsp:getProperty> 标记的 JSP 页面中使用，例如:
<jsp:useBean id="id" class="bean class name" scope="fully qualified path of bean">
<jsp:setProperty name="beans id" property="property name" value="value"/>
<jsp:getProperty name="beans id" property="property name"/>
...........
</jsp:useBean>
我们将在下一个教程中详细了解jsp:useBean标签。
JSP jsp:useBean标签
如果你想在 JSP 页面中使用 Action 标签与一个 JavaBeans 组件交互，你必须首先声明一个 bean。<jsp:useBean>是声明和初始化实际 bean 对象的一种方式。我们所说的 bean 是指 JavaBean 组件对象。 < jsp 的语法:useBean > 标签
<jsp:useBean id = "beanName" class = "className"
scope = "page | request | session | application">
这里 id 属性指定了 bean 的名称。范围属性指定存储豆的位置。类属性指定完全限定的类名。
给定以下内容的 useBean 声明:
<jsp:useBean id="myBean" class="PersonBean" scope="request" />
相当于下面的 java 代码，
PersonBean myBean = (PersonBean)request.getAttribute("myBean");
if(myBean == null)
{
myBean = new PersonBean();
request.setAttribute("myBean", myBean);
}
如果 jsp:useBean 标签与主体一起使用，则主体的内容仅在创建 Bean 时执行。如果 bean 已经存在于命名范围中，则跳过主体。
举个例子
在这个例子中，我们将看到如何使用<jsp:useBean>标准标签来声明和初始化 bean 对象。我们将使用 PersonBean 类作为 JavaBean 组件。
PersonBean.java
import java.io.Serializable;
public class **PersonBean** implements **Serializable**
{
private String **name**;
public *PersonBean*()
{
this.name="";
}
public void *setName*(String name)
{
this.name = name;
}
public String *getName*()
{
return name;
}
}
hello.jsp
<html>
<head>
<title>Welcome Page</title>
</head>
<**jsp:useBean** id="person" class="PersonBean" scope="request" />
<body>
*//Use the bean here...*
</body>
</html>
这里 jsp:useBean 在 jsp 页面中声明了一个“人”Bean，可以在那里使用。如何使用它，修改它，我们将在以后的课程中学习。
JSP jsp:getProperty标签
getProperty标记用于从 JavaBeans 实例中检索属性。getProperty 标记的语法如下:
<jsp:getProperty name="beanName" property="propertyName" />
name 属性表示 JavaBean 实例的名称。property 属性表示我们想要获取其值的 JavaBean 的属性。
Java Bean 的getProperty示例
下面是我们的 Java 类。
PersonBean.java
import java.io.Serializable;
public class PersonBean implements Serializable
{
private String name;
public PersonBean()
{
this.name="";
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
hello.jsp
<html>
<head>
<title>Welcome Page</title>
</head>
<jsp:useBean id="person" class="PersonBean" scope="request" />
<body>
Name of Person is : <jsp:getProperty name="person" property="name" />
</body>
</html>
这将打印属性的值。如果你需要改变财产的价值。让我们在下一课中学习如何设置属性的值。
jsp:setProperty标签
setProperty标记用于在 JavaBeans 实例中存储数据。setProperty标签的语法是:
<jsp:setProperty name="beanName" property="*">
<!-- or -->
<jsp:setProperty name="beanName" property="propertyName">
<!-- or -->
<jsp:setProperty name="beanName" property="propertyName" param="parameterName">
<!-- or -->
<jsp:setProperty name="beanName" property="propertyName" value="propertyValue">
name 属性指定 javaBean 实例的名称。这必须与 jsp:useBean 标签中指定的 id 属性相匹配。属性属性指定要访问的 bean 属性。
Java Bean 的setProperty示例
下面是我们的 Java 类。
PersonBean.java
import java.io.Serializable;
public class PersonBean implements Serializable
{
private String name;
public PersonBean()
{
this.name="";
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
hello.jsp
<html>
<head>
<title>Welcome Page</title>
</head>
<jsp:useBean id="person" class="PersonBean" scope="request" />
<jsp:setProperty name="person" property="name" value="Viraj" />
<body>
Name of Person is : <jsp:getProperty name="person" property="name" />
</body>
</html>
输出将是→人名是:维拉杰
同样，我们也可以有一个非常复杂的 Java Bean，它有许多属性。我们可以使用jsp:useBeanjsp:setPropertyjsp:getProperty轻松获取和设置所有属性。
JSP 高级
JSP 表达式语言
表达式语言被添加到 JSP 2.0 规范中。EL 的目的是产生无脚本的 JSP 页面。JSP 中 EL 的语法如下:
${expr}
这里 expr 是一个有效的 EL 表达式。表达式可以与静态文本/值混合，也可以与其他表达式组合形成更大的表达式。
EL 表达式是如何使用的？
在 JSP 页面中，EL 表达式有两种使用方式
-
As attribute values in standard and custom tags. Example:
<jsp:include page="${location}">其中位置变量在 jsp 页面中单独定义。
表达式也可以用在
jsp:setProperty中来设置一个属性值，使用其他的 bean 属性，比如:如果我们有一个名为 Square 的 bean，它有长度、宽度和面积属性。<jsp:setProperty name="square" property="area" value="${square.length*square.breadth}" /> -
以 HTML 标记输出:
<h1>Welcome ${name}</h1>
要停用 EL 表达式的求值，我们指定页面指令的isELIgnored属性如下:
<%@ page isELIgnored ="true|false" %>
JSP EL 隐式对象
以下是 EL 中的隐式对象:
| 隐式对象 | 描述 |
| 对象 | 它表示页面上下文对象。 |
| pageScope(页面范围) | 它用于访问在页面范围内设置的任何变量的值 |
| 请求作用域 | 它用于访问在请求范围内设置的任何变量值。 |
| 会话范围 | 它用于访问在会话范围内设置的任何变量值 |
| 应用范围 | 它用于访问在应用范围内设置的任何变量值 |
| 参数 | 将请求参数名称映射到单个值 |
| 参数值 | 将请求参数名称映射到相应的字符串值数组。 |
| 页眉 | 包含标题名称和单个字符串值的映射。 |
| 标题值 | 将包含标题名称的映射到相应的字符串值数组。 |
| 甜饼干 | 包含 cookie 名称和单个字符串值的映射。 |
JSP EL 示例
让我们举一个简单的例子来理解 JSP 表达式语言，
index.jsp
<form method="POST" action="welcome.jsp">
Name <input type="text" name="user" >
<input type="submit" value="Submit">
</form>
welcome.jsp
<html>
<head>
<title>Welcome Page</title>
</head>
<body>
<h1>Welcome ${param.name}</h1>
</body>
</html>
电致发光中可用的算术运算
以下是 el 中可用的算术运算符:
| 算术运算 | 操作员 |
| 添加 | + |
| 减法 | - |
| 增加 | * |
| 分开 | / and div |
| 剩余物 | % and mod |
逻辑和关系运算符在 EL 中可用
以下是逻辑运算符和Comparator在电致发光中的应用:
| 逻辑和关系运算符 | 操作员 |
| 等于 | == and eq |
| 不平等 | != and ne |
| 不到 | < and lt |
| 大于 | > and gt |
| 大于或等于 | >= and ge |
| 小于或等于 | <= and le |
| 和 | && and and |
| 或者 | || and or |
| 不 | ! and not |
JSTL 标准标签库
JSP 标准标签库(JSTL)是现成标签的标准库。JSTL 包含几个标签，通过提供一些现成的、已经实现的通用功能，可以从 JSP 页面中删除脚本代码。
JSTL 分为 5 组:
-
JSTL 核心: JSTL 核心提供 if、forEach、import、out 等几个核心标签，支持一些基本的脚本任务。JSP 页面中包含 JSTL 核心标签的网址为→
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> -
JSTL 格式化: JSTL 格式化库提供标签来格式化国际化网站的文本、日期和数字。在 JSP 页面中包含 JSTL 格式标签的网址是→
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> -
JSTL sql: JSTL sql 库支持关系数据库连接和标签，对 SQL 数据库执行插入、删除、更新、选择等操作。JSP 页面中包含 JSTL SQL 标签的网址是→
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %> -
JSTL XML: JSTL XML 库提供对 XML 处理的支持。它提供流量控制、转换功能等。JSP 页面中包含 JSTL XML 标签的网址是→
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %> -
JSTL 函数: JSTL 函数库支持字符串操作。JSP 页面中包含 JSTL 函数标签的网址为→
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
JSP JSTL 核心图书馆
JSTL 核心库包含几个标签，可以用来消除基本的脚本开销，例如 JSP 页面中的for循环、if...else条件等。让我们研究一下 JSTL 核心图书馆的一些重要标签。
-
JSTL if 标记:if 标记是用于计算条件表达式的条件标记。当一个主体被提供了
if标记时，只有当表达式为真时，才计算该主体。例如:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title>Tag Example</title> </head> <body> <c:if test="${param.name == 'studytonight'}"> <p>Welcome to ${param.name} </p> </c:if> </body> </html>
-
JSTL out tag: The out tag is used to evaluate an expression and write the result to JspWriter. For Example :
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title>Tag Example</title> </head> <body> <c:out value="${param.name}" default="StudyTonight" /> </body> </html>value属性指定要写入 JspWriter 的表达式。default属性指定表达式计算为空时要写入的值。
-
JSTL forEach tag: This tag provides a mechanism for iteration within a JSP page. JSTL
forEachtag works similarly to enhanced for loop of Java Technology. You can use this tag to iterate over an existing collection of items. For Example :<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title>Tag Example</title> </head> <body> <c:forEach var="message" items="${errorMsgs}" > <li>${message}</li> </c:forEach> </body> </html>这里，属性项的值是一个 EL 表达式，它是错误消息的集合。迭代中的每一项都将存储在一个名为 message 的变量中，该变量在 forEach 标记的主体中可用。
-
JSTL choose, when, otherwise tag: These are conditional tags used to implement conditional operations. If the test condition of the
whentag evaluates to true, then the content withinwhentag is evaluated, otherwise the content within theotherwisetag is evaluated.我们也可以通过使用多个 when 标签来实现
if-else-if构造。当标签是互斥的，这意味着评估为真的第一个当标签被评估，然后，控制退出choose块。如果当条件都不为真，则评估otherwise条件。例如
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Tag Example</title>
</head>
<body>
<c:forEach var="tutorial" items="${MyTutorialMap}" begin="0" end="5" varStatus="status">
<c:choose>
<c:when test="${status.count %2 == 0 }">
<p> Divisible by 2 : ${tutorial.key} </p>
<br/>
</c:when>
<c:when test="${status.count %5 == 0 }">
<p > Divisible by 5 : ${tutorial.key} </p>
<br/>
</c:when>
<c:otherwise>
<p> Neither divisible by 2 nor 5 : ${tutorial.key} </p><br/>
</c:otherwise>
</c:choose>
</c:forEach>
</body>
</html>
-
JSTL 导入标签:
< c:import>标签用于在请求时将提供的网址中的内容动态添加到当前页面。< c:import>网址属性中使用的网址资源可以来自网络容器之外。例如:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title>Tag Example</title> </head> <body> <c:import url="http://www.example.com/hello.html">> <c:param name="showproducts" value="true"/> </c:import> </body> </html>
- JSTL url 标签:JSTL url 标签用于将 url 存储在变量中，必要时还会执行 URL 重写。例如
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Tag Example</title>
</head>
<body>
<a href='<c:url value="/home.jsp"/>' > Go Home </a>
</body>
</html>
-
JSTL 集合标记:JSTL 集合标记用于存储指定范围内的变量或更新 JavaBean 实例的属性。下面是设置学生 bean 的名称属性的示例:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title>Tag Example</title> </head> <body> <c:set target="student" property="name" value="${param.name}" /> </body> </html>
-
JSTL catch 标记:JSTL catch 标记用于处理异常，不会将页面转发到错误页面。例如:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title>Tag Example</title> </head> <body> <c:catch> <% int a = 0; int b = 10; int c = b/a; %> </c:catch> </body> </html>
JSP 自定义标签
当 EL 和标准动作元素不足以从 JSP 页面中移除脚本代码时，可以使用自定义标签。自定义标签只是用户定义的标签。
自定义标签是一种很好的方式，可以从网页的呈现中抽象出业务逻辑的复杂性，这种方式对于 Web 作者来说很容易使用和控制。它还允许重用，因为自定义标签可以反复使用。
JSP 自定义标记的格式
自定义标记的格式可以是空的，称为空标记，也可以包含正文，称为正文标记。标签将接受的属性数量取决于标签处理程序类的实现。
空标记的语法是:
<tagLibraryPrefix:customTagName attribute1="attributeName"
attribute2="attributeName" ... />
自定义正文标记的语法是:
<tagLibraryPrefix:customTagName attribute1="attributeName"
attribute2="attributeName" ... />
< --Body of custom tag-- >
</tagLibraryPrefix:customTagName>
在 JSP 世界中，创建自定义标签被认为是一种非常好的做法。始终尝试从 JSP 应用中经常使用的操作中创建和使用您自己的自定义标记。让我们进入下一课，学习如何创建自定义标签。
在 JSP 中创建自定义标签
原文：https://www.studytonight.com/jsp/creating-a-custom-tag.php
要创建自定义标签，需要以下组件:
- 应该扩展
SimpleTagSupport的标签处理程序类。 - 标签库描述符(TLD) 文件
- 在 JSP 文件中使用自定义标签
标签处理程序类
您可以通过两种不同的方式创建标记处理程序类:
- 通过实现三个接口之一:
SimpleTag、Tag或BodyTag，它们定义了在标签的生命周期中调用的方法。 - 通过扩展实现
SimpleTag、Tag或BodyTag接口的抽象基类。简单标签支持、标签支持和身体标签支持类实现简单标签、标签和标签接口。扩展这些类使标记处理程序类不必实现接口中的所有方法，并且还提供了其他方便的功能。
标签库描述符
标签库描述符是一个 XML 文档，它包含关于整个库以及库中包含的每个标签的信息。网络容器和 JSP 页面开发工具都使用顶级域名来验证标签。
标签库描述符文件必须具有扩展名.tld，并且必须打包在 WAR 文件的 /WEB-INF/ 目录或子目录中，或者打包在 JAR 中的标签库的 /META-INF/ 目录或子目录中。
自定义标签示例
在我们的例子中，我们将创建一个扩展标签支持类的标签处理程序类。当我们扩展这个类时，我们必须覆盖方法doStartTag()。这个类还有另外两个方法，即doEndTag()和release()，我们可以根据自己的需求决定是否覆盖。
CountMatches.java
package com.studytonight.taghandler;
import java.io.IOException;
import javax.servlet.jsp.*;
import org.apache.commons.lang.StringUtils;
public class **CountMatches** extends **TagSupport** {
private String **inputstring**;
private String **lookupstring**;
public String **getInputstring**() {
return inputstring;
}
public void **setInputstring**(String *inputstring*) {
this.inputstring = inputstring;
}
public String **getLookupstring**() {
return lookupstring;
}
public void **setLookupstring**(String *lookupstring*) {
this.lookupstring = lookupstring;
}
@Override
public int **doStartTag**() throws JspException {
try {
JspWriter out = pageContext.getOut();
out.println(StringUtils.countMatches(inputstring, lookupstring));
}
catch (IOException e) {
e.printStackTrace();
}
return SKIP_BODY;
}
}
在上面的代码中，我们有一个doStartTag()方法的实现，如果我们要扩展标记支持类，这是必须的。我们已经声明了两个变量inputstring和lookupstring。这些变量表示自定义标签的属性。我们必须为这些变量提供 getter 和 setter，以便将值设置到这些变量中，这些变量将在使用这个自定义标记时提供。我们还可以指定这些属性是否是必需的。
计数匹配作家. tld
<?xml version="*1.0*" encoding="*UTF-8*"?>
<taglib>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>**cntmtchs**</shortname>
<info>Sample taglib for Substr operation</info>
<uri>*http://studytonight.com/jsp/taglib/countmatches*</uri>
<tag>
<name>**countmatches**</name>
<tagclass>**com.studytonight.taghandler.CountMatches**</tagclass>
<info>String Utility</info>
<attribute>
<name>**inputstring**</name>
<required>**true**</required>
</attribute>
<attribute>
<name>**lookupstring**</name>
<required>**true**</required>
</attribute>
</tag>
</taglib>
taglib 元素指定了模式、所需的 JSP 版本以及这个标签库中的标签。TLD 中的每个标签元素代表库中存在的一个单独的自定义标签。这些标记中的每一个都应该有一个与之关联的标记处理程序类。
uri 元素表示唯一标识标签库的统一资源标识符。
标签元素中的两个属性元素表示标签有两个属性，提供给必需元素的真值表示标签正常工作需要这两个属性。
test.jsp
<%@taglib prefix="**mytag**" uri="*/WEB-INF/CountMatchesDescriptor.tld*"%>
<html>
<**mytag:countmatches** inputstring="*Studytonight*" lookupstring="*t*">
</**mytag:countmatches**>
</html>
如果这个标签工作正常，它应该在浏览器中打印一个值3，因为“今晚学习”这个词中出现了 3 次“不”。
Java 类型转换
类型变换
如何将 Java int转换为String
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-int-to-string
在 Java 中，我们可以通过两种方式将int转换为字符串:
-
通过使用 String.valueOf() 方法
-
通过使用 Integer.toString() 方法
也可以使用一些替代方法，如String.format()方法、字符串连接运算符等。
1.通过使用String.valueOf()方法
()方法的值是字符串类的一部分。这是一个静态方法，它将 int 值转换为 String 值。
例 1:
这里，方法中传递的 int 值被转换成一个字符串。
public class Main
{
public static void main(String args[])
{
int n = 500;
System.out.println("The int value is " +n);
String s = String.valueOf(n);
System.out.println("The string value is " +s);
}
}
int 值为 500
字符串值为 500
2.通过使用Integer.toString()方法
toString() 方法是整数类的一部分。这是一个静态方法，也可以用来将 int 值转换为字符串。
例 2:
这里，在toString()方法中传递一个 int 值以获得一个String值。
public class Main
{
public static void main(String args[])
{
int n = 500;
System.out.println("The int value is " +n);
String s = Integer.toString(n);
System.out.println("The string value is " +s);
}
}
int 值为 500
字符串值为 500
3.通过使用String.format()方法
format() 方法是字符串类的一部分，用于格式化字符串中的给定参数。
例 3:
这里，在format()方法中传递一个 int 值以获得一个String值。
public class Studytonight
{
public static void main(String args[])
{
int n = 500;
System.out.println("The int value is " +n);
String s = String.format("%d",n);
System.out.println("The string value is " +s);
}
}
int 值为 500
字符串值为 500
4.通过使用+运算符(连接)
我们可以使用+运算符将任意值连接成一个字符串。+运算符在连接后返回一个String对象。请看下面的例子。
例 4:
这里，一个int值与一个 emty 字符串连接，将 int 转换为String。
public class Studytonight
{
public static void main(String args[])
{
int n = 500;
System.out.println("The int value is " +n);
String s = "" + n;
System.out.println("The string value is " +s);
}
}
int 值为 500
字符串值为 500
如何将 Java 字符串转换为int
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-int
在 Java 中，可以使用 Integer.pareseInt() 方法和 Integer.valueOf() 方法将字符串转换为 int 值。
例如，当我们接收到字符串形式的用户输入，并且要求在执行任何数学运算之前将其转换为整数时。这可以通过 parseInt() 方法完成。
使用Integer.parseInt() 方法转换
parseInt()方法是整数类的一部分。这是一个静态方法，用于将字符串转换为整数。这里，一个string值被转换成int值。
例 1:
public class StudyTonight
{
public static void main(String args[])
{
String s = "454"; //String Declaration
System.out.println("String value "+s);
int i = Integer.parseInt(s);
System.out.println("Integer value "+i);
}
}
字符串值 454
整数值 454
使用Integer.valueOf()方法转换
valueOf()方法是整数类的一部分。此方法用于将String转换为integer。请看下面的例子。
例 2:
如果提供的字符串不包含有效的数字，则valueOf()方法返回异常。
public class StudyTonight
{
public static void main(String args[])
{
try
{
String s1 = "500"; //String declaration
Integer i1 = Integer.valueOf(s1); // Integer.valueOf() method converts a String into Integer
System.out.println(i1);
String s2 = "mohit"; //NumberFormatException
Integer i2 = Integer.valueOf(s2);
System.out.println(i2);
}
catch(Exception e)
{
System.out.println("Invalid input");
}
}
}
500
无效输入
例 3:
转换也可以手动完成，如示例所示:
class StudyTonight
{
public static int strToInt(String str)
{
int i = 0;
int num = 0;
boolean isNeg = false;
// Check for negative sign; if it's there, set the isNeg flag
if (str.charAt(0) == '-')
{
isNeg = true;
i = 1;
}
// Process each character of the string;
while( i < str.length())
{
num *= 10;
num += str.charAt(i++) - '0'; // Minus the ASCII code of '0' to get the value of the charAt(i++).
}
if (isNeg)
num = -num;
return num;
}
public static void main(String[] args)
{
String s = "45734";
int i = strToInt(s);
System.out.println("Int value is : "+i);
}
}
Int 值为:45734
如何将 Java 字符串转换为long
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-long
在 Java 中，可以使用 Long.parseLong() 方法和 Long.valueOf() 方法将一个字符串转换为一个长值。
Java Long.parseLong() 法
parseLong() 法是 Long 类的一部分。这是一种静态方法，用于将字符串转换为长值。
例 1:
这里，使用 parseLong() 方法将字符串值转换为长值。
public class StudyTonight
{
public static void main(String args[])
{
String s = "454"; //String Decleration
long i = Long.parseLong(s); // Long.parseLong() converts the string into long
System.out.println(i);
}
}
454
Java Long.valueOf() 法
()法的值是龙类的一部分。此方法用于将String转换为Long对象。
例 2:
在这里，字符串值被转换为长值。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
try
{
String s1 = "500"; //String declaration
Long i1 = Long.valueOf(s1); // Long.valueOf() method converts a String into Long
System.out.println(i1);
String s2 = "mohit"; //NumberFormatException
Long i2 = Long.valueOf(s2);
System.out.println(i2);
}
catch(Exception e)
{
System.out.println("Invalid input");
}
}
}
500
无效输入
使用longValue()方法的转换示例
这里，使用返回 long 对象的长值的longValue()方法将字符串值转换为长值。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
String s="454"; //String Decleration
Long obj = new Long(s);
long n = obj.longValue();
System.out.println("Long value is : " +n );
}
}
长值为:454
如何将 Java long转换为String
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-long-to-string
在 Java 中，我们可以通过两种方式将long转换为字符串，或者使用 valueOf() 方法，或者使用 toString() 方法。
1.通过使用String.valueOf()方法
()方法的值是字符串类的一部分。这是一种将长值转换为字符串值的静态方法。
例 1:
这里，在方法中传递一个长值，并使用 valueOf() 方法将其转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
long n = 500L;
String s = String.valueOf(n);
System.out.println("The string value is " +s);
}
}
字符串值为 500
2.通过使用Long.toString()方法
toString() 方法是龙类的一部分。这是一种静态方法，也可用于将长值转换为字符串。
例 2:
这里，在toString()方法中传递一个长值以转换成字符串。
public class StudyTonight
{
public static void main(String args[])
{
long n = 500L;
String s = Long.toString(n);
System.out.println("The string value is " +s);
}
}
字符串值为 500
3.通过使用连接过程
我们可以使用+运算符将长值与字符串对象连接起来，然后得到字符串作为结果。+运算符在连接后返回一个字符串对象。
public class StudyTonight
{
public static void main(String args[])
{
long n = 500L;
String longString = ""+n; //concatenation
System.out.println("String is : "+longString);
}
}
字符串为:500
如何将 Java 字符串转换为float
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-float
在 Java 中，可以使用 Float.parseFloat() 方法和 Float.valueOf() 方法将字符串转换为浮点值。让我们看看转换。
1.通过使用Float.parseFloat() 方法
parseFloat() 方法是 Float 类的一部分。这是一种static方法，用于将字符串转换为浮点值。
例 1:
这里，使用 parseFloat() 方法将字符串值转换为浮点值。
public class StudyTonight
{
public static void main(String args[])
{
String s = "454.86"; //String Decleration
float i = Float.parseFloat(s); // Float.parseFloat() converts the string into float
System.out.println(i);
}
}
454.86
2.通过使用Float.valueOf()方法
()方法的值是浮动类的一部分。此方法用于将String转换为Float对象。
例 2:
这里，使用valueOf()方法将字符串值转换为浮点值。
public class Main
{
public static void main(String args[])
{
try
{
String s1 = "500.778"; //String
float i1 = Float.valueOf(s1); // Float.valueOf() method converts a String into float
System.out.println(i1);
String s2 = "mohit"; //NumberFormatException
float i2 = Float.valueOf(s2);
System.out.println(i2);
}
catch(Exception e)
{
System.out.println("Invalid input");
}
}
}
500.778
无效输入
3.通过使用floatValue()方法
例 3:
这里，考虑到字符串中可能出现的额外空格，使用floatValue()方法将字符串转换为浮点值。
public class StudyTonight
{
public static void main (String[] args)
{
String s = "34.00";
try
{
float f = Float.valueOf(s.trim()).floatValue();
System.out.println("float value is = " + f);
}
catch (NumberFormatException nfe)
{
System.out.println("NumberFormatException: " + nfe.getMessage());
}
}
}
浮点值为= 34.0
如何将 Java float转换为字符串
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-float-to-string
在 Java 中，我们可以通过两种方式将float转换为String:
-
通过使用 String.valueOf() 方法
-
通过使用 Float.toString() 方法
1.通过使用String.valueOf()方法
()方法的值是字符串类的一部分。这是一个静态方法，将浮点转换为字符串值。
例 1:
这里，方法中传递的浮点值被转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
float n = 500.08f;
String s = String.valueOf(n);
System.out.println("The string value is " +s);
}
}
字符串值为 500.08
2.通过使用Float.toString()方法
toString() 方法是 Float 类的一部分。这是一个静态方法，也可以用来将浮点值转换为字符串。
例 2:
这里，方法中传递的浮点值被转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
float n = 500.08f;
String s = Float.toString(n);
System.out.println("The string value is " +s);
}
}
字符串值为 500.08
3.通过使用format()方法
我们可以使用DecimalFormat类的format()方法来获取浮点值的字符串值。这里，一个float值被传递到方法中，并被转换成一个格式为 2 位数的String。
import java.text.DecimalFormat;
public class StudyTonight
{
public static void main(String args[])
{
float n = 500.0878f;
Float f = (float)n;
String s = new DecimalFormat ("#.00").format (f); //for two places decimal
System.out.println("String is : "+s);
}
}
字符串为:500.09
4.通过使用+运算符(连接)
我们可以使用+运算符将浮点值连接到一个空字符串，并获得一个字符串值。这里，在方法中传递一个浮点值，并使用连接将其转换为字符串。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
float n = 500.0878f;
String str = ""+n; //concat
System.out.println("String is : " + str);
}
}
字符串为:500.0878
如何将 Java 字符串转换为double
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-double
在 Java 中，可以使用 Double.parseDouble() 方法将字符串转换为双精度值。另外，可以使用 Double.valueOf() 方法将字符串转换为 Double 对象。
每当从文本字段或文本区域接收到数据(数字)时，它都是以字符串的形式出现的，如果我们想要双精度类型，那么在执行任何数学运算之前，需要将其转换为双精度类型。这是通过 parseDouble() 方法完成的。
1.通过使用Double.parseDouble()方法
parseDouble() 方法是 Double 类的一部分。这是一个静态方法，用于将字符串转换为双精度值。
例 1:
这里，使用 parseDouble()方法将字符串值转换为Double类型值。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
String s="454.90"; //String Decleration
double i = Double.parseDouble(s); // Double.parseDouble() converts the string into double
System.out.println(i);
}
}
454.9
2.使用Double.valueOf()方法购买
()法的值是双类的一部分。此方法用于将String转换为Double对象。
例 2:
这里，使用valueOf()方法将String值转换为双精度值。
public class StudyTonight
{
public static void main(String args[])
{
try
{
String s1 = "500.77"; //String declaration
double i1 = Double.valueOf(s1); // Double.valueOf() method converts a String into Double
System.out.println(i1);
String s2 = "mohit"; //NumberFormatException
double i2 = Double.valueOf(s2);
System.out.println(i2);
}
catch(Exception e)
{
System.out.println("Invalid input");
}
}
}
500.77
无效输入
例 3:
如果我们想要转换一个包含逗号的值，那么使用replaceAll()方法来替换逗号，使用parseDouble()方法来获得双精度值。这里，考虑到逗号，字符串值被转换为双精度值。
public class StudyTonight
{
public static void main(String args[])
{
String s = "4,54,8908.90"; //String Decleration
//replace all commas if present with no comma
String s1 = s.replaceAll(",","").trim();
// if there are any empty spaces also take it out.
String f = s1.replaceAll(" ", "");
//now convert the string to double
double result = Double.parseDouble(f);
System.out.println("Double value is : "+ result);
}
}
双值为:4548908.9
如何将 Java double转换为字符串
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-double-to-string
在 Java 中，我们可以通过以下两种方式将double转换为String:
-
通过使用 String.valueOf() 方法
-
通过使用 Double.toString() 方法
1.通过使用String.valueOf()方法
()方法的值是字符串类的一部分。这是一个将双精度值转换为字符串值的静态方法。
例 1:
这里，方法中传递的双精度值被转换成String。
public class StudyTonight
{
public static void main(String args[])
{
double n = 500.88;
String s=String.valueOf(n);
System.out.println("The string value is " +s);
System.out.println(n+100); //will return 600.88 because + is binary plus operator
System.out.println(s+100);//will return 500.88100 because + is string concatenation operator
}
}
字符串值为 500.88
600.88
500.88100
2.通过使用Double.toString()方法
toString() 方法是双类的一部分。这是一种static方法，也可以用来将双精度值转换为字符串。
例 2:
这里，方法中传递的双精度值被转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
double n = 500.77;
String s = Double.toString(n);
System.out.println("The string value is " +s);
System.out.println(n+100); //will return 600 because + is binary plus operator
System.out.println(s+100);//will return 500100 because + is string concatenation operator
}
}
字符串值为 500.77
600.77
500.77100
例 3:
这里，在方法中传递的双精度值被转换成一个String格式的数字，达到指定的位数。
import java.text.DecimalFormat;
public class StudyTonight
{
public static void main(String args[])
{
double num = 500.88;
System.out.println(String.format ("%f", num));
System.out.println(String.format ("%.9f", num));
DecimalFormat decimalFormat = new DecimalFormat("#,##0.000000");
String numberAsString = decimalFormat.format(num);
System.out.println(numberAsString);
}
}
500.88 万
500.88 万
500.88 万
例 4:
这里，方法中传递的双精度值使用连接转换为String。
public class StudyTonight
{
public static void main(String args[])
{
double num = 500.88;
String s = num+""; //concat
System.out.println(s);
}
}
500.88
如何将 Java 字符串转换为日期对象
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-date
在 Java 中，字符串可以使用LocalDate和SimpleDateFormat类的parse()方法转换成日期。
SimpleDateFormat 根据指定的日期格式解析字符串。例如日/月/年、月、日、年等。
例 1:
这里String使用SimpleDateFormat类的parse()方法转换成指定格式的Date。
import java.text.SimpleDateFormat;
import java.util.Date;
public class StudyTonight
{
public static void main(String [] args)throws Exception
{
String d1 = "23/02/1997";
String d2 = "23-Feb-1997";
String d3 = "02 23, 1997";
String d4 = "Sun, Feb 23 1997";
String d5 = "Sun, Feb 23 1997 22:12:21";
String d6 = "23-Feb-1997 22:12:21";
SimpleDateFormat f1 = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat f2 = new SimpleDateFormat("dd-MMM-yyyy");
SimpleDateFormat f3 = new SimpleDateFormat("MM dd, yyyy");
SimpleDateFormat f4 = new SimpleDateFormat("E, MMM dd yyyy");
SimpleDateFormat f5 = new SimpleDateFormat("E, MMM dd yyyy HH:mm:ss");
SimpleDateFormat f6 = new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");
Date date1 = f1.parse(d1);
Date date2 = f2.parse(d2);
Date date3 = f3.parse(d3);
Date date4 = f4.parse(d4);
Date date5 = f5.parse(d5);
Date date6 = f6.parse(d6);
System.out.println(d1+"\t"+date1);
System.out.println(d2+"\t"+date2);
System.out.println(d3+"\t"+date3);
System.out.println(d4+"\t"+date4);
System.out.println(d5+"\t"+date5);
System.out.println(d6+"\t"+date6);
}
}
1997 年 2 月 23 日 sun feb 23 00:00:00 utc 1997
1997 年 2 月 23 日 sun feb 23:00:00 utc 1997
1997 年 2 月 23 日 sun 23:00:00:00 utc 1997
1997 年 2 月 23 日 sun feb 23:00:00:00 utc 1997
1997 年 2 月 23 日 sun 22:12:21 sun feb 23:12:21 utc 1997
示例 2: Java 8 -本地日期类
如果您使用的是 Java 8 或更高版本，那么您可以使用DateTimeFormatter类来格式化日期，使用LocalDate类来将字符串转换为日期对象。请看下面的例子。
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
public class StudyTonight {
public static void main(String[] args) {
String string = "January 12, 2020";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(string, formatter);
System.out.println(date);
}
}
2020-01-12
如何将 Java 日期转换为字符串
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-date-to-string
在 Java 中，日期可以用DateFormat和Instant类等几个类转换成字符串。DateFormat类提供了一个返回字符串对象的方法format()。DateFormat级属于java.text套餐。
1.通过使用format()方法
format()方法是DateFormat类的一部分，它是一个抽象类，用于将Date转换为String。SimpleDateFormat班是DateFormat班的一个子班。
例 1:
这里Date使用SimpleDateFormat类的format()方法转换为String。
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Calendar;
public class StudyTonight
{
public static void main(String [] args)throws Exception
{
Date d = Calendar.getInstance().getTime();
DateFormat df = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
String sDate = df.format(d);
System.out.println("String in form of Date is : " + sDate);
}
}
转换字符串:2020-27-29 03:27:15
2.通过使用toString()方法
String类的toString()方法用于获取任意类型对象的字符串对象。这里，我们使用toString()将日期对象转换为String类型。请看下面的例子。
package com.studytonight;
import java.util.Date;
public class CoreJava {
public static void main(String[] args) {
Date date = new Date();
String fullDate = date.toString();
System.out.println(fullDate);
String dateString = fullDate.substring( 0 , 11 );
System.out.println(dateString);
String timeString = fullDate.substring( 11 , 19 );
System.out.println(timeString);
}
}
Thu Nov 26 11:54:45 是 2020
Thu Nov 26
11:54:45
在 Java 中 8 java.time包
如果您使用的是 Java 8 或更高版本，则使用toInstant()方法获取即时对象，该对象可用于将日期转换为字符串。Instant 类用于使日期对象与 java 8 或更高版本兼容。请看下面的例子。
package com.studytonight;
import java.time.Instant;
import java.util.Date;
public class CoreJava {
public static void main(String[] args) {
Date date = new Date();
Instant instant = date.toInstant();
String fullDate = instant.toString();
System.out.println(fullDate);
String dateString = fullDate.substring( 0 , 10 );
System.out.println(dateString);
String timeString = fullDate.substring( 11 , 19 );
System.out.println(timeString);
}
}
2020-11-26t 06:31:20.445 z
2020-11-26
06:31:20
如何将 Java 字符串转换为字符
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-char
在 Java 中，一个字符串可以通过使用 String 类的内置方法和自己的自定义代码转换成一个 char。以下是本主题中将用于将字符串转换为字符的方法。
-
charAt() 方法
1.通过使用charAt()方法
charAt() 方法是弦类的一部分。此方法用于返回指定索引的单个字符。必须注意的是，这个方法只返回一个字符，为了得到多个字符，应该使用循环。
例 1:
通过使用 charAt() 方法，从给定字符串中返回指定索引处的字符charAt(0)返回字符串的第一个字符。
public class StudyTonight
{
public static void main(String args[])
{
String s = "studytonight";
char c = s.charAt(0);//returns s
System.out.println("1st character is: " +c);
}
}
第一个字符为:s
例 2:
这里，使用循环将整个字符串转换为字符。
public class StudyTonight
{
public static void main(String args[])
{
String s = "mohit";
for(int i=0; i<s.length();i++)
{
char c = s.charAt(i);
System.out.println("char at "+i+"th index is: "+c);
}
}
}
第 0 个索引处的字符为:m 第 1 个索引处的字符为:o 第 2 个索引处的字符为:h 第 3 个索引处的字符为:I 第 4 个索引处的字符为:t
2.通过使用toCharArray()方法
toCharArray() 方法是弦类的一部分。此方法将字符串转换为字符数组。
例 3:
这里，使用toCharArray()方法将字符串转换为字符数组。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
String s = "mohit";
for(int i=0; i<s.length();i++)
{
char[] c = s.toCharArray();
System.out.println("char at "+i+"th index is: "+c[i]);
}
}
}
第 0 个索引处的字符为:m 第 1 个索引处的字符为:o 第 2 个索引处的字符为:h 第 3 个索引处的字符为:I 第 4 个索引处的字符为:t
如何将 Java 字符转换为字符串
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-char-to-string
在 Java 中，我们可以使用 String 类将 char 转换成字符串。类提供了返回字符串的方法。让我们用例子来看看。
1.通过使用String.valueOf()方法
valueOf() 方法是String类的一部分。这是一种将字符转换为字符串值的静态方法。
例 1:
这里，方法中传递的字符值被转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
char ch = 'D';
String s = String.valueOf(ch); //valueOf() method converts character into String
System.out.println("The string value is " +s);
}
}
字符串值为 D
2.通过使用Character.toString()方法
toString()法是人物类的一部分。这是一种静态方法，也可用于将字符转换为字符串。
例 2:
这里，在方法中传递一个字符值，并将其转换为String。请看下面的例子。
package com.studytonight;
public class StudyTonight
{
public static void main(String args[])
{
char ch = 'M';
String s = Character.toString(ch);
System.out.println("The string value is " +s);
}
}
字符串值为 M
例 3:
这里，在方法中传递一个字符值，并使用连接将其转换为字符串。我们使用+运算符将字符值与空字符串连接起来。+运算符在连接后返回一个字符串。
public class StudyTonight
{
public static void main(String args[])
{
char ch = 'D';
String s = "" + ch;
System.out.println("The string is : "+s);
}
}
弦是:D
例 4:
这里，通过创建字符值的字符串实例，将方法中传递的字符值转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
char ch = 'D';
String s = new String(new char[]{ch});
System.out.println("The string is : "+s);
}
}
弦是:D
例 5:
这里，方法中传递的字符值使用toString()转换为字符串。
package com.studytonight;
public class StudyTonight
{
public static void main(String args[])
{
char ch = 'D';
String s = new Character(ch).toString();
System.out.println("The string is : "+s);
}
}
弦是:D
如何将 Java 字符串转换为对象
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-object
在 Java 中，一个字符串可以通过简单的赋值操作符转换成一个对象。这是因为对象类在内部是每个类的父类，因此，字符串可以直接分配给对象。
另外，可以使用Class.forName()方法将字符串转换为对象。
1.使用赋值(=)操作符
例 1:
这里，使用赋值运算符将字符串转换为对象。
public class StudyTonight
{
public static void main(String args[])
{
String s = "welcome to studytonight";
Object ob = s;
System.out.println("Object value is " +ob);
}
}
欢迎今晚研究对象值
2.使用Class.forName()方法
Class.forName()方法用于返回 Class 类的实例，用于获取一个类的元数据。
例 2:
这里，返回Class类的元数据和实例。
public class StudyTonight
{
public static void main(String args[])throws Exception
{
String str = "studytonight";
System.out.println(str);
Object o = (Object)str;
System.out.println(o);
}
}
今晚学习
今晚学习
如何将 Java 对象转换为字符串
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-object-to-string
在 Java 中，可以使用toString()和valueOf()方法将一个对象转换为字符串。这两种方法都属于String类。我们可以将一个对象转换成String而不管它是不是用户定义的类、StringBuffer、StringBuilder等等。
例 1:
这里，类Student的对象是转换为字符串的用户定义的类。
package com.studytonight;
class Student // user-defined class
{
String name;
int id;
public Student(String name, int id) {
super();
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Name: "+name+" Id: "+id;
}
}
public class StudyTonight
{
public static void main(String args[])
{
Student ob = new Student("Irfan",12); //object of user-defined class Student
System.out.println(ob +" "+ob.getClass());
String s1 = ob.toString();
System.out.println(s1+" "+s1.getClass());
}
}
姓名:伊尔凡 Id: 12 班 com . study 今夜.学生
姓名:伊尔凡 Id: 12 班 java.lang.String
例 2:
这里StringBuilder类对象转换为 String。
public class StudyTonight
{
public static void main(String args[])
{
String s = "Welcome to studytonight";
StringBuilder sb = new StringBuilder(s);
String sr = sb.toString();
System.out.println("String is: "+sr);
}
}
字符串为:欢迎今晚学习
如何将 Java int转换为long
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-int-to-long
在 Java 中，int值可以通过简单的赋值运算符转换成long值。这是因为这个转换是一个 隐式类型转换 ，其中较低的数据类型会自动转换为较高的数据类型。
例 1:
这里，int值通过赋值运算符隐式转换为long值。
public class StudyTonight
{
public static void main(String args[])
{
int i = 500;
long l = i;
System.out.println(" The long value is : " +l);
}
}
长值为:500
此外，我们可以通过实例化Long类或使用 Long.valueOf() 方法将int值转换为 Long 对象。
例 2:
这里，通过实例化类并使用 valueOf() 方法，将int值转换为 Long 对象。
public class StudyTonight
{
public static void main(String args[])
{
int i = 200;
long l = Long.valueOf(i); //conversion using the valueOf() method
System.out.println(i);
System.out.println(l);
}
}
200
200
例 3:
这里，int值通过实例化长值隐式转换为long值。
public class StudyTonight
{
public static void main(String args[])throws Exception
{
int n = 232;
long l = new Long(n);
System.out.println("long value is : " +l);
}
}
长值为:232
如何将 Java long转换为int
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-long-to-int
在 Java 中，可以使用类型转换操作符将long转换为int。这是因为，为了将较高的数据类型转换为较低的数据类型，需要执行类型转换，这种类型的转换称为 类型转换 。
在 Java 中，类型转换是通过类型转换运算符(数据类型)来执行的。
例 1:
这里，使用类型转换操作符将原始long值转换为int。
public class StudyTonight
{
public static void main(String args[])
{
long l = 500L;
int i = (int)l; //typecasting
System.out.println("The int value is " +i);
}
}
整数值为 500
另外，我们可以通过 Long 类的 intValue() 方法将一个 Long 对象转换为一个 int。
例 2:
这里Long对象通过 intValue() 方法转换为 int。
public class StudyTonight
{
public static void main(String args[])
{
Long l = new Long(50);
int i = l.intValue();
System.out.println("The int value is : " +i);
}
}
int 值为:50
例 3:
这里，使用Math类的toIntExact()方法将原始long值转换为int。
public class StudyTonight
{
public static void main(String args[])
{
long l = 100L;
int i = Math.toIntExact(l);
System.out.println("The int value is " +i);
}
}
整数值为 100
如何将 Java int转换为double
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-int-to-double
在 Java 中，int值可以通过简单的赋值运算符转换成double值。这是因为该转换是类型提升(隐式类型转换)的一个例子，其中较低的数据类型被自动转换为较高的数据类型。
例 1:
这里，int值通过赋值运算符隐式转换为double值。
public class StudyTonight
{
public static void main(String args[])
{
int i = 500;
double l = i;
System.out.println(" The double value is : " +l);
}
}
双值为:500.0
此外，我们可以通过实例化 Double 类或使用 Double.valueOf() 方法将int值转换为 Double 对象。
例 2:
这里，通过实例化类并使用 valueOf() 方法将int值转换为双精度值。
public class StudyTonight
{
public static void main(String args[])
{
int i = 200;
double d1 = new Double(i); //conversion using the instantiation
double d2 = Double.valueOf(i); //conversion using the valueOf() method
System.out.println(d1);
System.out.println(d2);
}
}
200.0
200.0
如何将 Java double转换为int
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-double-to-int
在 Java 中，可以使用类型转换操作符将double转换为int。这是因为，为了将较高的数据类型转换为较低的数据类型，需要执行类型转换，这种类型的转换称为类型转换。
在 Java 中，类型转换是通过类型转换运算符(数据类型)来执行的。
例 1:
这里，使用 typecasting 运算符将基元双精度值转换为 int。
public class StudyTonight
{
public static void main(String args[])
{
double d = 500.0;
int i = (int)d; //typecasting
System.out.println("The int value is " +i);
}
}
整数值为 500
另外，我们可以通过 Double 类的 intValue() 方法将一个 double 对象转换成一个 int。
例 2:
这里Double对象通过 intValue() 方法转换为 int。
public class StudyTonight
{
public static void main(String args[])
{
Double d = new Double(50.78);
int i = d.intValue();
System.out.println("The int value is : " +i);
}
}
int 值为:50
例 3:
这里，基元双精度值被转换成 int 类型的值。
public class StudyTonight
{
public static void main(String args[])
{
Double myDouble = Double.valueOf(10.0);
int val = Integer.valueOf(myDouble.intValue());
System.out.println("The int value is : " +val);
}
}
int 值为:10
如何将 Java 字符转换为int
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-char-to-int
在 Java 中，可以通过以下方式将字符值转换为 int
-
直接将字符值赋给将返回字符 ASCII 值的 int。
-
使用字符串值方法
1.获取 ASCII 值
当一个字符值被直接赋值为 int 时，它返回赋给该字符值的整数 ASCII 值。
例 1:
这里，返回与 char 变量相关联的 ASCII 值。
public class StudyTonight
{
public static void main(String args[])
{
char c1 = 'm';
char c2 = 'M';
int n1 = c1;
int n2 = c2;
System.out.println("The equivalent ASCII value is " +n1);
System.out.println("The equivalent ASCII value is " +n2);
}
}
等效 ASCII 值为 109
等效 ASCII 值为 77
2.Character.getNumericValue()方法
getNumericValue() 方法是字符类的一部分，该类返回字符的数值(int)。
例 2:
这里，使用character . getnumericvalue()方法返回分配给该字符的 int 值。
public class StudyTonight
{
public static void main(String args[])
{
char ch = '8';
int n = Character.getNumericValue(ch);
System.out.println("The int value is : " +n);
}
}
int 值为:8
3.Integer.parseInt() 法
parseInt()方法是Integer类的一部分，返回指定对象值的 int 值。
例 3:
这里先将字符值转换为字符串，然后使用parseInt()方法转换为整数。整数值返回到指定的字符值。
public class StudyTonight
{
public static void main(String args[])
{
char ch = '5';
int n = Integer.parseInt(String.valueOf(ch));
System.out.println("The integer value is " +n);
}
}
整数值为 5
如何将 Java int转换为char
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-int-to-char
在 Java 中，一个int可以使用 打字 转换成一个char值。这是因为为了将较高的数据类型转换为较低的数据类型，需要执行类型转换。与整数值相关联的 ASCII 字符将存储在 char 变量中。
“0”与 int 变量相加，以获得 char 变量的实际值。另外，可以使用 Character.forDigit() 方法。
打字
类型转换是通过类型转换运算符将较高的数据类型转换为较低的数据类型来完成的。
例 1:
这里采用了各种情况，将 int 转换为 char。
public class StudyTonight
{
public static void main(String args[])
{
int n1 = 65;
char ch1 = (char)n1;
System.out.println(ch1);
int n2 = 98;
char ch2 = (char)n2;
System.out.println(ch2);
int n3 = 102;
char ch3 = (char)(n3);
System.out.println(ch3);
}
}
A
b
f
使用Character.forDigit()方法转换
forDigit() 方法是字符类的一部分，根据基数值返回特定数字的字符。
例 2:
这里，int 值(数字)根据基数值转换为 char。
public class StudyTonight
{
public static void main(String args[])
{
int r1 = 10;
int r2 = 16;
int a = 7;
char ch1= Character.forDigit(a,r1);
System.out.println(ch1);
char ch2 = Character.forDigit(a,r2);
System.out.println(ch2);
}
}
7
7
例 3:
这里，使用toString()和charAt()方法将 int 值(数字)转换为 char。请看下面的例子。
public class StudyTonight
{
public static void main(String[] args)
{
int a = 1;
char b = Integer.toString(a).charAt(0);
System.out.println(b);
}
}
1
如何将 Java 字符串转换为布尔值
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-string-to-boolean
在 Java 中，字符串可以通过Boolean.parseBoolean(string)和 valueOf()方法转换成布尔值。
为了获得布尔真，字符串必须包含“真”而不考虑大小写(大写真或小写真)。除“true”之外的任何其他字符串值都将返回布尔值 false。
1.Boolean.parseBoolean(string)方法
parseBoolean()方法是布尔类的一部分，用于将字符串值转换为布尔值。
语法:
以下是语法:
public static boolean parseBoolean(String s)
例 1:
这里，字符串 s1 和 s2 将为布尔真，所有其他字符串将返回布尔假。
public class StudyTonight
{
public static void main(String args[])
{
String s1 = "true";
String s2 = "TRUE";
String s3 = "studytonight";
boolean b1=Boolean.parseBoolean(s1);
boolean b2=Boolean.parseBoolean(s2);
boolean b3=Boolean.parseBoolean(s3);
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
真
真
假
此外，可以使用Boolean.valueOf()方法将String转换为Boolean对象。
2.Boolean.valueOf()方法
valueOf()方法是Boolean类的一部分，返回传递的String值的布尔对象。
例 2:
这里，返回传递的字符串的布尔值。
public class StudyTonight
{
public static void main(String args[])
{
String s1 = "true";
String s2 = "TRUE";
String s3 = "studytonight";
boolean b1 = Boolean.valueOf(s1);
boolean b2 = Boolean.valueOf(s2);
boolean b3 = Boolean.valueOf(s3);
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
真
真
假
如何将 Java 布尔值转换为字符串
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-boolean-to-string
在 Java 中，我们可以通过两种方式将boolean转换成字符串，或者使用 Java 中的valueOf()或者toString()方法。让我们看看例子。
1.通过使用String.valueOf()方法
()方法的值是字符串类的一部分。这是一种将布尔值转换为字符串值的静态方法。
例 1:
这里传递一个布尔值，该值被转换成一个字符串。
public class StudyTonight
{
public static void main(String args[])
{
boolean b1 = true;
boolean b2 = false;
String s1 = String.valueOf(b1);
String s2 = String.valueOf(b2);
System.out.println("The string value is : " +s1);
System.out.println("The string value is : " +s2);
}
}
字符串值为:真
字符串值为:假
2。通过使用 Boolean.toString()方法
toString()方法是布尔类的一部分。这是一种静态方法，也可用于将布尔值转换为字符串。
例 2:
这里，在方法中传递的布尔值被转换为字符串。
public class StudyTonight
{
public static void main(String args[])
{
boolean b1 = true;
boolean b2 = false;
String s1 = Boolean.toString(b1);
String s2 = Boolean.toString(b2);
System.out.println("The string value is " +s1);
System.out.println("The string value is " +s2);
}
}
字符串值为真
字符串值为假
如何将 Java 日期转换为时间戳
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-date-to-timestamp
在 Java 中，日期可以通过使用TimeStamp类的构造器转换成TimeStamp，该类是java.sql包的一部分。
必须注意的是，时间戳类的构造器将日期作为长值作为参数，因此必须使用java.util包的Date类的getTime()方法将日期转换为长值。
例 1:
这里日期转换为TimeStamp。
import java.sql.Timestamp;
import java.util.Date;
public class CoreJava
{
public static void main(String args[])
{
Date d = new Date(); //object of Date class
Timestamp t = new Timestamp(d.getTime());
System.out.println(t);
}
}
2020-09-24 04:41:32.471
例 2:
这里，时间戳值是使用java.text包的SimpleDateFormat类的构造器以 yyyy-MM-dd HH:mm: ss 格式格式化的。
import java.sql.Timestamp;
import java.util.Date;
import java.text.SimpleDateFormat;
public class StudyTonight
{
public static void main(String args[])
{
Date d = new Date();
Timestamp t = new Timestamp(d.getTime());
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(f.format(t));
}
}
2020-09-24 04:49:06
例 3:
这里，字符串日期使用Timestamp类的valueOf()方法转换为TimeStamp。
import java.sql.Timestamp;
import java.util.Date;
import java.text.SimpleDateFormat;
public class CoreJava
{
public static void main(String args[])
{
String input = "2007-11-11 12:13:14" ;
Timestamp ts = Timestamp.valueOf( input ) ;
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd ");
System.out.println(f.format(ts));
}
}
2007-11-11
如何将 Java 时间戳转换为日期
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-timestamp-to-date
在 Java 中，TimeStamp可以使用java.util包的Date类的构造器转换成日期。
必须注意的是日期类将参数作为长值，因此TimeStamp对象需要转换为长值。这是使用java.sql包的Timestamp类的getTime() 方法完成的。
例 1:
这里TimeStamp使用Date构造器转换成Date。请看下面的例子。
import java.sql.Timestamp;
import java.util.Date;
public class StudyTonight
{
public static void main(String args[])
{
Timestamp t = new Timestamp(System.currentTimeMillis()); //for current time in milliseconds
Date d = new Date(t.getTime());
System.out.println(d);
}
}
因此，09 月 24 日 05:28:11 UTC 2020
例 2:
此外，Timestamp类扩展了Date类。因此，Timestamp类的实例可以直接分配到日期中，并且可以获得像时间戳这样的输出。但是，这是不可取的，因为在这种情况下毫秒和纳秒可能会丢失。
import java.sql.Timestamp;
import java.util.Date;
public class StudyTonight
{
public static void main(String args[])
{
Timestamp t = new Timestamp(System.currentTimeMillis());
Date d = t;
System.out.println(d);
}
}
2020-09-24 05:48:58.627
例 3:
这里TimeStamp转换成Date，格式转换成各种格式。
import java.sql.Timestamp;
import java.text.DateFormat;
import java.util.Date;
import java.text.SimpleDateFormat;
public class StudyTonight
{
public static void main(String args[])
{
Timestamp stamp = new Timestamp(System.currentTimeMillis());
Date date = new Date(stamp.getTime());
DateFormat f = new SimpleDateFormat("yyyy-MM-dd");
DateFormat f1 = new SimpleDateFormat("yyyy/MM/dd");
String d = f.format(date);
String d1 = f1.format(date);
System.out.println(d);
System.out.println(d1);
}
}
2020-10-15
2020/10/15
如何将 Java 二进制转换为十进制
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-binary-to-decimal
在 Java 中，可以使用integer . parsent()方法和自己创建的自定义代码将二进制转换为十进制。让我们看看例子。
1.Integer.parseInt()方法
parseInt() 方法是 Integer 类的一部分，该类根据指定的基数将字符串转换为 Int。
例 1:
这里，二进制字符串被转换成十进制值。如果二进制文件是String类型的，或者我们可以先将值转换为字符串，然后应用 parseInt()方法，那么这个例子非常有用。请看下面的例子。
public class Studytonight
{
public static void main(String args[])
{
String b1 = "111010";
String b2 = "11001010";
String b3 = "1110";
int d1 = Integer.parseInt(b1,2);
int d2 = Integer.parseInt(b2,2);
int d3 = Integer.parseInt(b3,2);
System.out.println("Decimal value is : " +d1);
System.out.println("Decimal value is : " +d2);
System.out.println("Decimal value is : " +d3);
}
}
小数值为:58
小数值为:202
小数值为:14
例 2:
如果您不想使用任何内置方法，那么就使用这个将二进制值转换为十进制值的自定义代码。请看下面的例子。
public class CoreJava
{
public static int decimalconvt(int bin)
{
int dec = 0;
int n = 0;
while(true)
{
if(bin == 0)
{
break;
}
else
{
int t = bin % 10;
dec+= t * Math.pow(2, n);
bin = bin/10;
n++;
}
}
return dec;
}
public static void main(String args[])
{
System.out.println("Decimal of 1010001 is: "+decimalconvt(1010001));
System.out.println("Decimal of 1010110 is: "+decimalconvt(1010110));
System.out.println("Decimal of 11111011 is: "+decimalconvt(11111011));
}
}
1010001 的小数为:81
1010110 的小数为:86
11111011 的小数为:251
如何将 Java 十进制转换为二进制
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-decimal-to-binary
在 Java 中，十进制值可以通过 Integer.toBinaryString() 方法或自己的自定义代码转换成二进制值。让我们看看例子。
1.Integer.toBinaryString()方法
toBinaryString() 方法是 Integer 类的一部分，它将十进制转换为二进制字符串，二进制字符串还可以转换为其他类型，如int或float。
例 1:
这里，使用toBinaryString()方法将十进制值转换为二进制字符串。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
int d1 = 7;
int d2 = -232;
int d3 = 90902;
String b1 = Integer.toBinaryString(d1);
String b2 = Integer.toBinaryString(d2);
String b3 = Integer.toBinaryString(d3);
System.out.println("Binary value is : " +b1);
System.out.println("Binary value is : " +b2);
System.out.println("Binary value is : " +b3);
}
}
二进制值为:111
二进制值为:1111111111111111100011000
二进制值为:101100011000010110
例 2:
可以使用自定义逻辑将十进制值转换为二进制值。当您不想使用任何内置方法时，就是这种情况。
public class StudyTonight
{
public static void main(String [] args)
{
int dec = 343;
int bin[] = new int[30];
int i = 0;
while(dec > 0)
{
bin[i++] = dec%2;
dec = dec/2;
}
for(int j = i-1; j >= 0 ;j--)
{
System.out.print(bin[j]);
}
System.out.println();
}
}
101010111
如何将 Java 十六进制转换为十进制
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-hexadecimal-to-decimal
在 Java 中，十六进制可以通过integer . parsent()方法或者自定义 Logic 转换成十进制。
1.Integer.parseInt()方法
parseInt() 方法是 Integer 类的一部分，该类根据指定的基数将字符串转换为 Int。
例 1:
这里，十六进制字符串被转换成十进制值。当我们有字符串格式的数据时，这个方法很有用。意思是如果要用parseInt()方法，那么先把数据转换成字符串，然后得到十进制值。
public class StudyTonight
{
public static void main(String args[])
{
String b1 = "78F";
String b2 = "-56578D";
String b3 = "996B";
int d1 = Integer.parseInt(b1,16);
int d2 = Integer.parseInt(b2,16);
int d3 = Integer.parseInt(b3,16);
System.out.println("Decimal value is : " +d1);
System.out.println("Decimal value is : " +d2);
System.out.println("Decimal value is : " +d3);
}
}
小数值为:1935
小数值为:-5658509
小数值为:39275
例 2:
如果您不想使用任何内置方法，请使用此自定义代码，使用自定义逻辑将十六进制值转换为小数。请看下面的例子。
public class StudyTonight
{
public static int decimalconvt(String hexadec)
{
String seq = "0123456789ABCDEF";
hexadec = hexadec.toUpperCase();
int val = 0;
for (int i = 0; i < hexadec.length(); i++)
{
char ch = hexadec.charAt(i);
int d = seq.indexOf(ch);
val = 16*val + d;
}
return val;
}
public static void main(String args[])
{
System.out.println("Decimal of 101D is: " +decimalconvt("101D"));
System.out.println("Decimal of 156F is: " +decimalconvt("17856D"));
System.out.println("Decimal of -17BAED is: " +decimalconvt("-17BAED"));
}
}
101D 的小数为:4125
156F 的小数为:1541485
的小数为-17BAED 的小数为:-15222035
如何将 Java 十进制转换为十六进制
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-decimal-to-hexadecimal
在 Java 中，Decimal 可以使用integer . to exstring()方法或自己的自定义代码转换成十六进制。让我们看看例子。
1.Integer.toHexString()方法
to exstring()方法是 Integer 类的一部分，该类将十进制字符串转换为十六进制字符串，而十六进制字符串又可以转换为int或float类型。
例 1:
这里，使用toHexString()方法将十进制值转换为十六进制字符串。
public class StudyTonight
{
public static void main(String args[])
{
int d1 = 7;
int d2 = -232;
int d3 = 90902;
String h1 = Integer.toHexString(d1);
String h2 = Integer.toHexString(d2);
String h3 = Integer.toHexString(d3);
System.out.println("Binary value is : " +h1);
System.out.println("Binary value is : " +h2);
System.out.println("Binary value is : " +h3);
}
}
二进制值为:7
二进制值为:ffffff18
二进制值为:16316
例 2:
可以使用自定义逻辑将十进制值转换为十六进制值。
public class StudyTonight
{
public static void main(String [] args)
{
int dec = 34673;
int r;
String hex = "";
char hexch[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
while(dec>0)
{
r = dec % 16;
hex = hexch[r]+hex;
dec = dec/16;
}
System.out.println("The hexadecimal value is " +hex);
}
}
十六进制值为 8771
如何将 Java 八进制转换成十进制
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-octal-to-decimal
在 Java 中，八进制值可以通过integer . parsent()方法或者自己的自定义代码转换成十进制值。让我们看看例子。
1.Integer.parseInt()方法
parseInt() 方法是 Integer 类的一部分，该类根据指定的基数将字符串转换为 Int。
例 1:
这里，使用parseInt()方法将八进制字符串值转换为十进制值。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
String o1 = "75";
String o2 = "-56573";
String o3 = "336";
int d1 = Integer.parseInt(o1,8);
int d2 = Integer.parseInt(o2,8);
int d3 = Integer.parseInt(o3,8);
System.out.println("Decimal value is : " +d1);
System.out.println("Decimal value is : " +d2);
System.out.println("Decimal value is : " +d3);
}
}
小数值为:61
小数值为:-23931
小数值为:222
例 2:
八进制值可以使用自定义逻辑转换为小数。当您不想使用任何内置方法时，这很有用。
public class StudyTonight
{
public static int decimalconvt(int oct)
{
int dec = 0;
int n = 0;
while(true)
{
if(oct == 0)
{
break;
}
else
{
int tmp = oct%10;
dec += tmp*Math.pow(8, n);
oct = oct/10;
n++;
}
}
return dec;
}
public static void main(String args[])
{
System.out.println("Decimal of 101 is: " +decimalconvt(101));
System.out.println("Decimal of 1756 is: " +decimalconvt(1756));
System.out.println("Decimal of -1743 is: " +decimalconvt(-1743));
}
}
101 的小数为:65
1756 的小数为:1006
1743 的小数为:-995
如何将 Java 十进制转换为八进制
原文：https://www.studytonight.com/java-type-conversion/how-to-convert-java-decimal-to-octal
在 Java 中，十进制值可以通过使用 Integer.toOctalString() 方法或自己的自定义代码转换成八进制值。让我们看看例子。
1.Integer.toOctalString()方法
toOctalString() 方法是 Integer 类的一部分，它将十进制字符串转换为八进制字符串，八进制字符串还可以转换为任何类型。
例 1:
这里，使用toOctalString()方法将十进制值转换为八进制字符串。请看下面的例子。
public class StudyTonight
{
public static void main(String args[])
{
int d1 = 7;
int d2 = -232;
int d3 = 30402;
String h1 = Integer.toOctalString(d1);
String h2 = Integer.toOctalString(d2);
String h3 = Integer.toOctalString(d3);
System.out.println("Octal value is : " +h1);
System.out.println("Octal value is : " +h2);
System.out.println("Octal value is : " +h3);
}
}
八进制值为:7
八进制值为:3777777430
八进制值为:73302
例 2:
可以使用自定义逻辑将十进制值转换为八进制值。
public class StudyTonight
{
public static void main(String [] args)
{
int dec = 34673;
int r;
String oct = "";
char octchars[]={'0','1','2','3','4','5','6','7'};
while(dec>0)
{
r = dec%8;
oct = octchars[r]+oct;
dec = dec/8;
}
System.out.println("Octal value is " +oct);
}
}
八进制值为 103561
Java 包装类
Java Integer类方法
Java Integer.bitCount()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-bitcount-method
Java bitCount()方法属于Integer类。此方法用于将一个一位数返回为指定整数值的二进制补码形式，并对二进制序列中的设置位数进行计数。
这个方法将一个整数作为参数，并返回一个整数。例如，如果给定的输入是 1000111110 ，那么这个方法应该返回 6 ，因为在这个输入中有 6 设置位(1) 。
语法:
public static int bitCount(int i)
参数:
传递的唯一参数是整数，它的二进制补码形式将被返回。
返回:
该方法将一位数返回为整数的二进制补码形式，因此其返回类型也是int.
例 1:
这里，我们输入一个整数 365 。Integer.toBinaryString()方法会将数字转换为其等效的二进制字符串( 101101101 为整数 365 )。然后转换后的二进制数通过Integer.countBit()对位数进行计数。
import java.lang.Integer;
public class StudyTonight {
public static void main(String[] args) {
int i = 365;
int j = -365;
System.out.println("Actual Number is " + i);
// converting the number to its equivalent binary form with base 2
System.out.println("Binary conversion of" + i + " = " + Integer.toBinaryString(i));
//returning the number of one-bits
System.out.println("Number of one bits = " + Integer.bitCount(i));
System.out.println("*******************");
System.out.println("Actual Number is " + j);
System.out.println("Binary conversion of" + j + " = " + Integer.toBinaryString(j));
System.out.println("Number of one bits = " + Integer.bitCount(j));
}
}
实际数为 365
二进制转换的 365 = 101101101
一位数= 6
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4】实际数为-365
二进制转换的-365 = 111111111111111010010011
一位数= 27
- T4】实际数为-365
-
-
-
-
-
-
-
-
-
-
-
-
-
例 2:
这里，我们取一个整数数组。Integer.toBinaryString()方法将把数组中的数字转换成其等价的二进制字符串。二进制字符串在通过countBit()方法之前需要转换成整数，这是通过Integer.parseInt()方法完成的，然后转换后的二进制数通过Integer.countBit()来计数位数。
import java.lang.Integer;
public class StudyTonight {
public static void main(String args[]) {
int[] set = {
72,
78,
56,
89,
80,
66
};
try {
for (int i = 0; i < 6; i++) {
String b = Integer.toBinaryString(set[i]); //Converting the actual number to binary String
int c = Integer.parseInt(b, 2); //Converting the binary String to binary integer of base 2
int d = Integer.bitCount(c); //Counting the set bits
System.out.println("Actual number is " + set[i] + " binary sequence : " + b + ",number of set bits are : " + d);
}
}
catch(Exception e) {
System.out.println("Exception occurred..");
}
}
}
实际数为 72 二进制序列:1001000，设置位数为:2
实际数为 78 二进制序列:1001110，设置位数为:4
实际数为 56 二进制序列:111000，设置位数为:3
实际数为 89 二进制序列:1011001，设置位数为:4
实际数为 80 二进制序列:1010000，设置位数
例 3:
这里有一个通用的例子，用户可以输入他选择的数字并获得所需的输出。try和catch块用于处理程序执行期间发生的任何异常。(例如，用户输入字符串等。代替整数)。
import java.lang.Integer;
import java.util. * ;
public class StudyTonight {
public static void main(String[] args) {
System.out.println("Enter number");
Scanner sc = new Scanner(System. in );
try {
int i = sc.nextInt();
System.out.println("Actual Number is " + i);
// converting the number to its equivalent binary form with base 2
System.out.println("Binary conversion of" + i + " = " + Integer.toBinaryString(i));
//returning the number of one-bits
System.out.println("Number of one bits = " + Integer.bitCount(i));
}
catch(Exception e) {
System.out.println("Error!!");
}
}
}
输入数字
67
实际数字为 67
二进制转换 67 = 1000011
一位数= 3
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入数字
0x896
错误！！
- *输入数字
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.byteValue()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-bytevalue-method
Java byteValue()方法属于java.lang包的Integer 类，覆盖了Number类的byteValue()方法。此方法在缩小图元转换(将较高数据类型转换为较低数据类型)后，返回整数对象的等效字节。
简而言之，该方法用于将整数对象转换为字节值。
语法:
public byte byteValue()
参数:
此方法中没有传递任何参数。
返回:
转换后会创建Byte类型对象的数字等价物。
例 1:
在这里，使用byteValue()函数，整数值被转换成其数字字节等价物。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
//converting integer object into byte
Integer x = 95;
byte i=x.byteValue();
System.out.println(" Equivalent byte value is " +i);
Integer y = -25;
byte d = y.byteValue();
System.out.println(" Equivalent byte value is " +d);
}
}
等效字节值为 95
等效字节值为-25
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的字节值。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value to be converted : ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Integer n = i ;
byte val = n.byteValue();
System.out.println("Byte Value is: " + val);
}
catch(Exception e)
{
System.out.println("not a valid integer");
}
}
}
输入要转换的值:67
字节值为:67
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *要转换的值:---93
字节值为:-93
- *要转换的值:---93
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.compare()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-compare-method
Java compare()方法属于Integer 类。此方法用于比较两个整数的数值，找出哪个大于另一个。
compare(int x,int y) 方法返回该值
- 0 ;如果 x 和 y 的值相等。
- -1 ;如果 x 的值小于 y。
- 1;如果 x 的值大于 y。
语法:
public static int compare(int x, int y)
参数:
传递的参数由两个整数int x和int y 组成，分别表示要比较的第一个和第二个整数。
返回:
根据 x 和 y 的值，返回值 0，1，-1。
例 1:
这里，取四个整数 n1、n2、n3、n4，取其各自的正值，并检查其值是小于、大于还是等于比较值。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int n1 = 100;
int n2 = 200;
int n3 = 300;
int n4 = 100;
System.out.println(Integer.compare(n1, n2)); //Output will be less than zero
System.out.println(Integer.compare(n3, n1)); // Output will be greater than zero
System.out.println(Integer.compare(n1,n4)); // Output will be equal to zero
}
}
-1
1
0
例 2:
这里，在一个数组中取四个整数 n1、n2、n3、n4，并检查其值与数组的第一个值相比是少、多还是相等。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int []n = {-100,-200,300,-100};
for(int i=0;i<4;i++)
{
System.out.println(Integer.compare(n[0], n[i]));
}
}
}
0
1
-1
0
例 3:
这里有一个通用的例子，用户可以输入他选择的数字并获得所需的输出。try和catch块用于处理程序执行期间发生的任何异常。(例如，用户输入字符串等。代替整数)。
import java.util.Scanner;
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter first and second number ");
try
{
int n1 = sc.nextInt();
int n2 = sc.nextInt();
int r = Integer.compare(n1, n2);
if(r > 0)
{
System.out.println("first number is greater");
}
else if(r< 0)
{
System.out.println("second number is greater");
}
else
{
System.out.println("both numbers are equal");
}
}
catch(Exception e)
{
System.out.println("Error!!");
}
}
}
输入第一个和第二个数字 100 452
第二个数字大于
输入第一个和第二个数字 0x789 890
错误！！
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.compareTo()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-compareto-method
Java compareTo()方法属于Integer类。这个方法类似于同一个类的compare() 方法，但是唯一的区别是这里的整数对象是用数字而不是整数值来比较的。
object1.compareTo(int object2) 方法返回该值
-
0;如果对象 1 等于对象 2
-
-1;如果对象 1 小于对象 2
-
1;如果对象 1 大于对象 2
语法:
public int compareTo(Integer integer2)
参数:
参数包含要比较的整数对象。
返回:
0，-1，1，具体取决于参数整数的值。
例 1:
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Integer ob1 = 100;
Integer ob2 = 200;
Integer ob3 = 300;
Integer ob4 = 100;
System.out.println(ob1.compareTo(ob2)); //Output will be less than zero
System.out.println(ob3.compareTo(ob1)); // Output will be greater than zero
System.out.println(ob1.compareTo(ob4)); // Output will be equal to zero
}
}
-1
1
0
例 2:
这里，创建一个Integer对象的数组，并将数组中的每个对象与数组中的第一个对象进行比较。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Integer [] ob = {-100,-200,300,-100};
for(int i=0;i<4;i++)
{
System.out.println(ob[0].compareTo(ob[i])); // comparing each object of array with first object
}
}
}
0
1
1
0
例 3:
这里有一个通用的例子，用户可以输入他选择的数字并获得所需的输出。try和catch块用于处理程序执行期间发生的任何异常。(例如，用户输入字符串等。代替整数)。
import java.util.Scanner;
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter first and second number ");
try
{
Integer n1 = sc.nextInt();
Integer n2 = sc.nextInt();
int r = n1.compareTo(n2);
if(r > 0)
{
System.out.println("first number is greater");
}
else if(r< 0)
{
System.out.println("second number is greater");
}
else
{
System.out.println("both numbers are equal");
}
}
catch(Exception e)
{
System.out.println("Error!!");
}
}
}
输入第一个和第二个数字 121 898
第二个数字更大
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入第一个和第二个数字 100 60
第一个数字更大
- *输入第一个和第二个数字 100 60
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入第一个和第二个数字 0x555 0x565
错误！！
- *输入第一个和第二个数字 0x555 0x565
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.compareUnsigned()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-compareunsigned-method
Java compareUnsigned()方法属于java.lang包的Integer 类，由**Comparable<Integer>**接口指定。此方法用于比较传递的两个整数的无符号值，以找出哪一个大于另一个。
compareUnsigned(int x,int y) 方法返回值:
-
0;如果 x 和 y 的无符号值相等。
-
-1;如果 x 的无符号值小于 y。
-
1;如果 x 的无符号值大于 y。
语法:
public static int compareUnsigned(int x, int y)
参数:
传递的参数由两个整数int x和int y 组成，分别表示要作为无符号值进行比较的第一个和第二个整数。
返回:
根据 x 和 y 的值，返回值 0，1，-1。
例 1:
这里，取四个整数 n1、n2、n3、n4 的相应值，并检查这些值是小于、大于还是等于比较值。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int n1 = 100;
int n2 = -200;
int n3 = 300;
int n4 = 100;
System.out.println(Integer.compareUnsigned(n1, n2)); //Output will be less than zero
System.out.println(Integer.compareUnsigned(n3, n1)); // Output will be greater than zero
System.out.println(Integer.compareUnsigned(n1,n4)); // Output will be equal to zero
}
}
-1
1
0
例 2:
这里，在一个数组中取四个整数 n1、n2、n3、n4，并检查其值与数组的第一个值相比是少、多还是相等。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int []n = {-100,-200,300,100};
for(int i=0;i<4;i++)
{
System.out.println(Integer.compareUnsigned(n[0], n[i]));
}
}
}
0
1
1
1
例 3:
这里有一个通用的例子，用户可以输入他选择的数字并获得所需的输出。try和catch块用于处理程序执行期间发生的任何异常。(例如，用户输入字符串等。代替整数)。
import java.util.Scanner;
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter first and second number ");
try
{
int n1 = sc.nextInt();
int n2 = sc.nextInt();
int r = Integer.compareUnsigned(n1, n2);
if(r > 0)
{
System.out.println("first number is greater");
}
else if(r< 0)
{
System.out.println("second number is greater");
}
else
{
System.out.println("both numbers are equal");
}
}
catch(Exception e)
{
System.out.println("Error!!");
}
}
}
输入第一个和第二个数字-34 98
第一个数字较大
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Ineteger.decode()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-decode-method
Java decode()方法属于Integer类。decode()方法用于将“”形式的字符串解码为整数。
可接受的数字有:
-
小数
-
十六进制的
-
八进制的
语法:
public static Integer decode(String s) throws NumberFormatException
参数:
该参数包括将被解码为整数的字符串。
返回:
字符串保存的整数对象的整数值。
如果字符串不包含任何可解析的整数，则抛出**NumberFormatException**。
例 1:
这里，以“0”开头的数字将使用基数 8 解码为八进制，以“0x”开头的数字将使用基数 16 解码为十六进制，以“-0x”开头的数字将使用基数 16 解码为带符号的十六进制。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Integer i = 30;
String s = "300";
System.out.println(Integer.decode("05234")); // decoding using base 8
System.out.println(Integer.decode("0x980")); // decoding using base 16
System.out.println(Integer.decode("-0x786")); // decode using base 16 signed
System.out.println(" Decoded Integer Number for the given string is = " +i.decode(s));
// returns the integer value of the Integer object which the String s holds.
}
}
2716
2432
-1926
给定字符串的解码整数为= 300
例 2:
在这里，我们遇到了NumberFormatException ，因为字符串 s 不能被解码成整数。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Integer i = 100;
String s = "StudyTonight";
System.out.println(" Decoded integer number is = " + i.decode(s));
}
}
线程“main”Java . lang . numberformateexception 中的异常:对于输入字符串:“study night”
在 Java . lang . numberformateexception . For putstring(numberformateexception . Java:65)
在 Java . lang . integer . par sent(integer . Java:580)
在 Java . lang . integer . value of(integer . Java:740)
在 Java . lang . integer . decode(integer . Java:1197)
在 study night . main(study night . Java:T0)
例 3:
这里有一个通用的例子，用户可以输入他选择的数字并获得所需的输出。try和catch块用于处理程序执行期间发生的任何异常。
import java.lang.Integer;
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the string to be decoded: ");
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
Integer decoded = Integer.decode(s);
System.out.println("Decoded value is:" + decoded);
}
catch(Exception e)
{
System.out.println("Number Format Exception,Please Check the Entered String");
}
}
}
输入需要解码的字符串:-0x567
解码值为:-1383
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入需要解码的字符串:
今晚学习
数字格式异常，请检查输入的字符串
- *输入需要解码的字符串:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.divideUnsigned()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-divideunsigned-method
Java divideUnsigned()方法属于Integer 类。此方法用于返回第一个参数除以第二个参数得到的商(无符号)。结果，即商总是作为无符号值。
语法:
public static int divideUnsigned(int dividend, int divisor)
参数:
传递的参数将是int dividend将被划分，而int divisor将进行划分过程。
返回:
第一个自变量(即被除数)除以第二个自变量(即除数)时的无符号商。
例 1:
这里，正常的除法过程发生在所有整数都有符号的时候。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int a = 100;
int b = 5;
int c = 3;
System.out.println("Quotient of\t" + a+ "/" +b+ "\t is \t" +Integer.divideUnsigned(a, b));
System.out.println("Quotient of\t" + a+ "/" +c+ "\t is \t" +Integer.divideUnsigned(a, c));
}
}
100/5 的商是 20
100/3 的商是 33
例 2:
这里，整数 100 用-5 到+5 之间的数字来划分，以明确方法的概念。有符号整数的输出为零，无符号整数的相应商为零。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int a = 100;
try
{
for(int i=-5;i<=5;i++)
{
if(i==0)
{
System.out.println("Division with zero not possible");
}
else
{
System.out.println("Quotient of\t" + a+ "/" +i+ "\t is \t" +Integer.divideUnsigned(a, i));
}
}
}
catch(Exception e)
{
}
}
}
100/-5 的商为 0
100/-4 的商为 0
100/-3 的商为 0
100/-2 的商为 0
100/-1 的商为 0
除零不可能
100/1 的商为 100
100/2 的商为 50
100/3 的商为 33
100/4 的商为
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.doubleValue()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-doublevalue-method
Java doubleValue()方法属于Integer类。此方法在扩展原始类型转换(将较低的数据类型转换为较高的数据类型)后返回整数的双等值。
简而言之，该方法用于将一个整数对象转换为一个双精度值。
语法:
public double doubleValue()
参数:
此方法中没有传递任何参数。
返回:
转换后创建的双精度类型对象的等效数值。
例 1:
在这里，使用doubleValue()函数，整数值被转换成其数值的双等值。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
//converting integer object into double
Integer x = 99;
double i=x.doubleValue();
System.out.println(i);
Integer y = 23;
double d = y.doubleValue();
System.out.println(d);
}
}
99.0
23.0
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并得到等价的双精度值。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value to be converted : ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Integer n = i ;
double val = n.doubleValue();
System.out.println("Double Value is: " + val);
}
catch(Exception e)
{
System.out.println("not a valid integer");
}
}
}
输入要转换的值:800
双精度值为:800.0
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入要转换的值:89f
不是有效的整数
- *输入要转换的值:89f
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.equals()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-equals-method
Java equals()方法属于Integer类。此方法用于将当前使用的整数对象的值与参数的值进行比较。它的返回类型为布尔值，即如果整数对象的值等于参数的值，则返回 true 如果整数对象的值不等于参数的值，则返回 false。
该方法覆盖了Object类的equals()方法。
语法:
public boolean equals(Object obj)
参数:
传递的参数是要检查是否与整数相等的对象。
返回:
如果 Integer 对象值的值等于作为参数传递的值，则返回true，如果 Integer 对象值的值不等于作为参数传递的值，则返回false 。
例 1:
这里检查整数对象 ob1、ob2、ob3 是否相等。
public class StudyTonight
{
public static void main(String[] args)
{
Integer ob1 = 20;
Integer ob2 = 40;
Integer ob3 = 40;
//Checking for objects with equal and unequal values
System.out.println("ob1 and ob2 equal? "+ob1.equals(ob2));
System.out.println("ob2 and ob3 equal? "+ob2.equals(ob3));
}
}
ob1 和 ob2 相等？假
ob2 和 ob3 相等？真实的
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并得到想要的结果。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter first integer: ");
Integer n1 = sc.nextInt();
System.out.print("Enter second integer ");
Integer n2 = sc.nextInt();
boolean r = n1.equals(n2);
if (r==true)
{
System.out.println("Same numbers entered");
}
else
{
System.out.println("Different numbers entered");
}
}
catch(Exception e)
{
System.out.println("Invalid input!!Please check");
}
}
}
输入第一个整数:78
输入第二个整数 23
输入不同的数字
*******输入第一个整数:
输入第二个整数:89
输入第二个整数 89
输入相同的数字
*************************输入第一个整数:0x 09
输入无效！！请检查
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.floatValue()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-floatvalue-method
Java floatValue()方法属于java.lang包的Integer类。此方法在扩大基本转换(将较低的数据类型转换为较高的数据类型)后，返回整数的浮动等价物。
简而言之，该方法用于将整数对象转换为浮点值。
语法:
public float floatValue()
参数:
此方法中没有传递任何参数。
返回:
转换后创建的整数对象的浮点等价物。
例 1:
在这里，使用floatValue()函数，整数对象被转换成它的浮点等价物。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
//converting integer object into float
Integer x = 65;
float i=x.floatValue();
System.out.println(i);
Integer y = 90;
float d = y.floatValue();
System.out.println(d);
}
}
65.0
90.0
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等价的浮点值。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value to be converted : ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Integer n = i ;
float val = n.floatValue(); //converting integer object into float
System.out.println("Float Value is: " + val);
}
catch(Exception e)
{
System.out.println("not a valid integer");
}
}
}
输入要转换的值:23
浮点值为:23.0
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.getInteger(String)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-getintegerstring-method
Java getInteger(String nm)方法是 java.lang 包的Integer类的一部分。此方法用于确定与作为字符串参数传递的系统属性关联的整数值。如果传递的字符串没有附加系统属性，则返回 null。
语法:
public static Integer getInteger(String nm)
参数:
传递的参数是与系统属性相关联的字符串 nm，并且要确定同一系统属性的整数值。
返回:
与传递的字符串参数关联的系统属性的整数值。
例 1:
这里，Strings1sun . arch . data . model是一个系统属性，它决定了所使用的 JVM 版本。字符串s2“今晚学习”没有关联的系统属性，因此返回空值。
我们可以通过**System.getProperty(java.lang.String)**访问系统属性
但是，我们也可以使用System.**setProperty(String s, int n)**创建自己的系统属性，如下所示:
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
String s1 = "sun.arch.data.model";
System.out.println("Integer Value = "+Integer.getInteger(s1)); // It determines the integer value of the system property
String s2 = "StudyTonight"; //will return null because no system property is attached with this string
System.out.println("Integer Value = "+Integer.getInteger(s2));
System.setProperty("st.java", "23"); //set a custom property
System.out.println("Integer Value = " +Integer.getInteger("st.java"));
}
}
整数值= 64
整数值=空
整数值= 23
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the string value: ");
Scanner sc = new Scanner(System.in);
String s= sc.next();
System.out.println("Integer Value = "+Integer.getInteger(s)); //determines the integer value of the system property
}
catch(Exception e)
{
System.out.println("Invalid Input!!");
}
} }
输入字符串值:sun.arch.data.model
整数值= 64
*****************输入字符串值:mohit
整数值= null
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.getInteger(String, int)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-getintegerstring-default-val-method
Integer类的 java getInteger(String nm, int val)方法用于确定与作为字符串参数传递的系统属性相关联的整数值。第二个参数 val 是默认值，在以下情况下返回:
-
不存在给定名称的属性。
-
如果属性没有给出正确的数字格式
-
或者，传递的属性为 null 或空。
语法:
public static Integer getInteger(String nm, int val)
参数:
传递的参数有String nm 和int val，其中String nm 的系统属性整数值待定，而int val是缺省值，如果找不到系统属性，将返回缺省值。
返回:
与传递的字符串的系统属性关联的整数值，如果没有与该字符串关联的系统属性，则为默认值。
例 1:
这里，对于字符串 s，返回系统属性的整数值，对于没有系统属性值或名称的字符串，返回默认值。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
String s = "sun.arch.data.model";
System.out.println(Integer.getInteger(s, 0));//returns the integer value of the system property of string s
System.out.println(Integer.getInteger("java.vm.specification.vendor", 100)); // will return the default value as string as there is no property of the given name
System.out.println(Integer.getInteger("studytonight",0)); // will return the default value as string does not have a system property value
}
}
64
100
0
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the value and default value ");
Scanner sc = new Scanner(System.in);
String s = sc.next();
int i= sc.nextInt();
System.out.println("Default Value: "+Integer.getInteger(s, i)); //will returns the integer value of the system property
}
catch(Exception e)
{
}
}
}
输入数值和默认值
莫希特 78
默认值:78
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer getInteger(String, Integer)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-getintegerstring-integer-val-method
Integer类的 Java getInteger(String, Integer)方法也用于确定与作为字符串参数传递的系统属性相关联的整数值。这里的第二个参数也是默认值，但是返回的不是默认值，而是默认的 Integer 对象。
语法:
public static Integer getInteger(String nm, Integer val)
参数:
传递的参数是String nm 和Integer val，前者的系统属性整数值有待确定，后者是默认的整数对象，如果没有找到系统属性，将返回该对象。
返回:
如果没有与字符串关联的系统属性，则为与传递的字符串或默认整数对象的系统属性关联的整数值。
例 1:
这里，对于字符串 s，返回系统属性的整数值，对于没有系统属性值或名称的字符串，返回默认的 integer 对象。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
System.out.println(Integer.getInteger("java.vm.specification.vendor", 25));// Print default system property
System.out.println("Default value is:"+ Integer.getInteger("sun.arch.data.model")); //Prints the system property
// setting and printing the custom property
System.setProperty("studytonight.java", "80");
System.out.println("Custom Property: " + Integer.getInteger("studytonight.java"));
//printing a custom property which is not set will yield default value
System.out.println("Custom Property: " + Integer.getInteger("mohit", 90));
}
}
25
默认值为:64
自定义属性:80
自定义属性:90
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the value and default value ");
Scanner sc = new Scanner(System.in);
String s = sc.next();
Integer i= sc.nextInt(); //Integer object for default value
System.out.println("Value is : "+Integer.getInteger(s, i)); //will returns the integer value of the system property
}
catch(Exception e)
{
}
}
}
输入数值和默认值
莫希特 23
数值为:23
*****************输入数值和默认值
sun.arch.model.data 87
数值为:87
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.hashCode()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-hashcode-method
hashCode()方法是java.lang包的Integer类的一部分。它用于返回给定输入的哈希代码。hashcode 被定义为与 Java 中的每个对象相关联的唯一原始整数值。
该方法覆盖类Object.的方法
语法:
public int hashCode()
参数:
此方法中没有传递任何参数。
返回:
与整数对象关联的等效基本整数值(哈希代码)。
例外情况:
在执行此方法的过程中，可能会遇到以下异常:
InputMismatchExceptionNumberFormatException
例 1:
这里，使用 hashcode()函数，编译器返回一个 hashCode。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Integer n1 = 81;
Integer n2 = 27;
int hv1 = n1.hashCode();//Returning the hash code value for the object n1
int hv2 = n2.hashCode();//Returning the hash code value for the object n2
System.out.println("Hash code Value : " + hv1);
System.out.println("Hash code Value : " + hv2);
}
}
哈希码值:81
哈希码值:27
例 2:
这里有一个用户定义的例子，任何使用这个代码的人都可以输入自己选择的值，并获得等效的哈希代码。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter input: ");
Scanner sc = new Scanner(System.in);
Integer n = sc.nextInt();
int hv = n.hashCode(); //Returning the hash code value for the object
System.out.println("Hash code Value for the given input is: " + hv);
}
catch(Exception e)
{
System.out.println("Invalid Input!!");
}
}
}
输入输入:23
给定输入的哈希码值为:23
***************输入:今晚学习
输入无效！！
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.hashCode(int)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-hashcode-int-method
hashCode(int n)方法与 Java 1.8 或更高版本兼容，并且是java.lang包的Integer类的一部分。它用于返回作为参数传递的整数的哈希代码。
该方法与Integer类的**[Integer.hashCode()](https://www.studytonight.com/java-wrapper-class/java-integer-hashcode-method)**方法兼容。
语法:
public static int hashCode(int value)
参数:
参数包括要生成哈希代码的 int 值。
返回:
与作为参数传递的整数值关联的唯一整数值(哈希代码)。
例外情况:
在执行此方法的过程中，可能会遇到以下异常:
InputMismatchExceptionNumberFormatException
例 1:
这里，使用hashCode(int n)函数，传递的整数值被转换成其各自的 hashcode。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int hv1 = Integer.hashCode(27); //generate the hashcode of the passed argument
int hv2 = Integer.hashCode(81);
System.out.println("Hash code Value is: " + hv1);
System.out.println("Hash code Value is: " + hv2);
}
}
哈希码值为:27
哈希码值为:81
例 2:
这里有一个用户定义的例子，任何使用这个代码的人都可以输入自己选择的值，并获得等效的哈希代码。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value: ");
Scanner sc = new Scanner(System.in);
Integer i = sc.nextInt();
int hv = Integer.hashCode(i); // Returning hash code value for this object
System.out.println("Hash code is: " + hv);
}
catch(Exception e)
{
System.out.println("Invalid Input!!");
}
}
}
输入值:545
哈希码为:545
***********************输入值:莫希特
无效输入！！
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.highestOneBit()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-highestonebit-method
Java highestOneBit()方法是java.lang包的Integer类的一部分。此方法用于返回作为参数在最高阶(最左侧)位置传递的单个一位整数值，如果传递的参数为零，则返回零。
例如，int 17 的输入将返回 16；因为 17 可以用二进制表示为 10001，所以它将返回最左边的位，等于 16。
语法:
public static int highestOneBit(int n)
参数:
传递的参数是要返回其最高位的整数值。
返回:
返回最高位位置的单个一位整数值，如果传递的参数为零，则返回零。
例 1:
这里，20 的二进制表示是 10100，因此最高一位是 16，在负二进制的情况下，将考虑等价的二进制补码，并相应地取最高位。
public class StudyTonight
{
public static void main(String[] args)
{
int i=20;
int j=-12;
System.out.println(" highest-order one-bit Integer is: "+Integer.highestOneBit(i));
System.out.println(" highest-order one-bit Integer is: "+Integer.highestOneBit(j));
}
}
最高阶一位整数为:16
最高阶一位整数为:-2147483648
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the number : ");
Scanner sc = new Scanner(System.in);
Integer i = sc.nextInt();
System.out.println("Highest-order one-bit Integer is: "+Integer.highestOneBit(i));
}
catch(Exception e)
{
}
}
}
输入数字:90
最高阶一位整数为:64
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T3】输入数字:-54
最高阶一位整数为:-2147483648
- T3】输入数字:-54
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.intValue()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-intvalue-method
Java intValue()方法属于java.lang的Integer 类，继承自Number类。这是一个实例方法，返回指定数字的整数等价物。
一般是拆箱的方法。虽然在 Java 5 引入后，转换是自动完成的(自动装箱)，但是了解装箱和拆箱的概念对你来说很重要。
拆箱:将Integer转换为int被称为拆箱
拳击:一个int 到 Integer 的转换称为拳击。
语法:
public int intValue()
参数:
此方法中没有传递任何参数。
返回:
对象转换为 int(原始类型)后的数值。
例外:
这种方法可以遇到的例外是NullPointerException.
例 1:
在这里，使用intValue()函数，整数对象被转换为其数值 int 等价物。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
Integer n1 = 25;
Integer n2 = 46;
int i = n1.intValue(); // returns the value of the Integer object n1 as an int
int j = n2.intValue(); // returns the value of the Integer object n2 as an int
System.out.println("int value is " + i);
System.out.println("int value is " + j);
}
}
int 值为 25
int 值为 46
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的 int 值。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter The Value ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Integer n = i;
System.out.println("Integer Value is: " + n.intValue()); //Converting the Integer object into int
}
catch(Exception e)
{
System.out.println(" Invalid Input!!");
}
}
}
输入数值 38
整数值为:38
***********************输入数值学习 java
无效输入！！
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.longValue()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-longvalue-method
Java longValue()方法属于java.lang包的Integer 类，继承自Number类。该方法返回整数对象的长等价物。
简而言之，该方法用于将整数对象转换为长值。
语法:
public long longValue()
参数:
此方法中没有传递任何参数。
返回:
转换后创建的整数对象的长等价物。
例 1:
这里，使用longValue()函数，整数对象被转换成它的长等价物。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
//converting integer object into long
Integer x = 15;
long i=x.longValue();
System.out.println("Long value is " +i);
Integer y = 67;
long d = y.longValue();
System.out.println("Long value is " +d);
}
}
长值为 15
长值为 67
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的长值。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value to be converted : ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Integer n = i ;
long val = n.longValue(); //converting integer object into long
System.out.println("Long Value is: " + val);
}
catch(Exception e)
{
System.out.println("not a valid integer");
}
}
}
输入要转换的值:67
长值为:67
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.lowestOneBit()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-lowestonebit-method
Java lowestOneBit()方法是java.lang包的Integer类的一部分。此方法用于返回作为参数在最低顺序(最右侧)位置传递的单个一位整数值，如果传递的参数为零，则返回零。
例如，int 17 的输入将返回 1；由于 17 可以用二进制表示为 10001，因此它将返回最接近的右位，它等于 1。
语法:
public static int lowestOneBit(int n)
参数:
传递的参数是要返回其最低位的整数值。
返回:
如果传递的参数为零，则返回最低顺序位置的单个一位整数值和零。
例 1:
这里，17 的二进制等效值是 10001，因此最低一位是 1，在负二进制的情况下，将考虑等价的二进制补码，并相应地取最低位。
public class StudyTonight
{
public static void main(String[] args)
{
int i=17;
int j=-12;
System.out.println(" lowest-order one-bit Integer is: "+Integer.lowestOneBit(i));
System.out.println(" lowest-order one-bit Integer is: "+Integer.lowestOneBit(j));
}
}
最低阶一位整数为:1
最低阶一位整数为:4
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the number : ");
Scanner sc = new Scanner(System.in);
Integer i = sc.nextInt();
System.out.println("Lowest-order one-bit Integer is: "+Integer.lowestOneBit(i));
}
catch(Exception e)
{
}
}
}
输入数字:87
最低阶一位整数为:1
*****************输入数字:-65
最低阶一位整数为:1
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.max()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-max-method
Java max()方法是java.lang包的Integer类的一部分，由Math类的Math.max()方法指定。此方法用于返回作为参数传递的两个数字中数值较大的值(最大值)。
如果传递了一个正数和一个负数，则返回正值，但是如果传递的两个数字都是负数，则返回较小的数值。
语法:
public static int max(int a, int b)
参数:
传递的参数是用户用来检查传递的两个数字的最大值的数值。
返回:
作为参数传递的两个值中数值较大的值。
例 1:
这里，取一个正数和一个负数，因此返回正值，如果两者都为负值，则返回较小的值。
import java.lang.Integer;
public class StudyTonight {
public static void main(String[] args)
{
int x = 5485;
int y = -3242;
int z = -5645;
// print the larger number between x and y
System.out.println("Greater number is " + Integer.max(x, y));
// print the larger number between y and z
System.out.println("Greater number is " + Integer.max(y, z));
}
}
更大的数字是 5485
更大的数字是-3242
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the Two values: ");
Scanner sc= new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
//Print the larger number between a and b
System.out.println("Larger value is " + Integer.max(a, b));
}
catch(Exception e)
{
System.out.println("Exception occurred...");
}
}
}
输入两个值:
82 -67
较大的值是 82
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4】输入两个值:
43-67
较大的值是-43
- T4】输入两个值:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.min()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-min-method
Java min()方法是java.lang包的Integer类的一部分，由Math类的Math.min()方法指定。此方法用于返回作为参数传递的两个数字中数值较小的值(最小值)。
如果传递了一个正数和一个负数，则返回负值，但是如果传递的两个数字都是负数，则返回更大的数值。
语法:
public static int min(int a, int b)
参数:
传递的参数是用户用来检查传递的两个数字的最小值的数值。
返回:
作为参数传递的两个值中数值较低的值。
例 1:
这里，取一个正数和一个负数，因此返回负值，如果两者都是负数，则返回更大的值。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int x = 5485;
int y = -3242;
int z = -5645;
// print the smaller number between x and y
System.out.println("Lower number is " + Integer.min(x, y));
// print the smaller number between y and z
System.out.println("Lower number is " + Integer.min(y, z));
}
}
下数为-3242
下数为-5645
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the Two values: ");
Scanner sc= new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
//Print the smaller number between a and b
System.out.println("Smaller value is " + Integer.min(a, b));
}
catch(Exception e)
{
System.out.println("Exception occurred...");
}
}
}
输入两个值:
78 -98
较小的值为-98
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4】输入两个值:
45-65
较小的值为-65
- T4】输入两个值:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.numberofLeadingZeros()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-numberofleadingzeros-method
Java numberofLeadingZeros() 方法是java.lang包的Integer类的一部分。此方法用于返回作为参数传递的整数值的二进制补码的最高一位(最左边)之前的零位。换句话说，它将 int 值转换为二进制，并返回最高(最左边)一位之前的零位总数。
如果传递的值没有一位，即该值为零，则返回值 32。
语法:
public static int numberOfLeadingZeros(int i)
参数:
传递的参数是整数值，它的二进制补码零位在最高一位之前返回。
返回:
返回参数二进制补码的最高一位(最左边)之前的零位。
例 1:
这里，为了更好地理解该方法，取一个正数和一个负数。
Integer.toBinaryString方法用于表示传递数的等价二进制形式。
import java.lang.*;
public class StudyTonight
{
public static void main(String[] args)
{
int i = 170; //positive number
System.out.println("Original Number is " + i);
System.out.println("Binary representation is = " + Integer.toBinaryString(i)); // converting into binary string of base 2
System.out.println("Number of leading zeros is " + Integer.numberOfLeadingZeros(i)); //returns the number of zero bits preceding the highest-order one bit
int j=-57; //negative number
System.out.println("Original Number is " + j);
System.out.println("Binary representation is = " + Integer.toBinaryString(j)); // converting into binary string of base 2
System.out.println("Number of leading zeros is " + Integer.numberOfLeadingZeros(j)); //returns the number of zero bits preceding the highest-order one bit
}
}
原数为 170
二进制表示为= 10101010
前导零数为 24
原数为-57
二进制表示为= 111111111111111111000111
前导零数为 0
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.*;
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the number ");
Scanner sc = new Scanner(System.in);
int i=sc.nextInt();
System.out.println("Binary representation is = " + Integer.toBinaryString(i)); // converting into binary string of base 2
System.out.println("Number of leading zeros is " + Integer.numberOfLeadingZeros(i)); //returns the number of zero bits preceding the highest-order one bit
}
catch(Exception e)
{
System.out.println("Invalid input");
}
}
}
输入数字
67
二进制表示为= 1000011
前导零的个数为 25
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入数字
0x779
无效
- *输入数字
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.numberofTrailingZeros()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-numberoftrailingzeros-method
Java numberofTrailingZeros()方法是java.lang包的Integer类的一部分。此方法用于返回作为参数传递的整数值的二进制补码的最低一位(最右边)之后的零位。换句话说，它将 int 值转换为二进制，并返回最低(最右边)一位之后的零位总数。
如果传递的值没有一位，即该值为零，则返回值 32。
语法:
public static int numberOfTrailingZeros(int i)
参数:
传递的参数是一个整数值，它的零位数跟在返回的最低位之后。
返回:
返回所传递参数的最低一位(最右边)之后的零位数。
例 1:
这里，为了更好地理解该方法，取一个正数和一个负数。
Integer.toBinaryString方法用于表示传递数的等价二进制形式。
public class StudyTonight
{
public static void main(String[] args)
{
int i = 170; //positive number
System.out.println("Original Number is " + i);
System.out.println("Binary representation is = " + Integer.toBinaryString(i));
System.out.println("Number of trailing zeros is " + Integer.numberOfTrailingZeros(i));
//returns the number of zero bits following the lowest-order one bit
int j=-57; //negative number
System.out.println("Original Number is " + j);
System.out.println("Binary representation is = " + Integer.toBinaryString(j));
System.out.println("Number of trailing zeros is " + Integer.numberOfTrailingZeros(j));
//returns the number of zero bits following the lowest-order one bit
}
}
原数为 170
二进制表示为= 10101010
尾随零数为 1
原数为-57
二进制表示为= 1111111111111111111000111
前导零数为 0
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.*;
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the number ");
Scanner sc = new Scanner(System.in);
int i=sc.nextInt();
System.out.println("Binary representation is = " + Integer.toBinaryString(i));
System.out.println("Number of trailing zeros is " + Integer.numberOfTrailingZeros(i));
//returns the number of zero bits following the lowest-order one bit
}
catch(Exception e)
{
System.out.println("Invalid input");
}
}
}
输入数字
87
二进制表示为= 1010111
尾随零的个数为 0
*******************输入数字
0x324
无效
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.parseInt (CharSequence, int, int, int)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-parseint-charsequence-method
Java parseInt (CharSequence s, int beginText, int endText, int radix)方法是java.lang包的Integer类的一部分。根据从传递的起始索引开始并扩展到传递的(结束索引- 1)的整数基数值分析传递的字符序列后，此方法返回等效的有符号整数。
语法:
public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix) throws NumberFormatException
参数:
传递的参数是:
CharSequence s:需要解析的字符序列。
int beginIndex:开始解析的字符序列的索引。
int endIndex:字符序列的索引，直到解析将扩展到的地方。
int radix:传递字符序列所依据的整数值。
返回:
根据从开始索引开始并延伸到结束索引-1 的整数基数，返回解析字符序列后获得的等效整数值。
例外:
NullPointerException:当输入字符为空时，出现此异常。
NumberFormatException : 当输入字符序列不可解析时，会出现此异常。
IndexOutOfBoundsException:当开始索引为负，或者开始索引值大于结束索引值，或者结束索引值大于 s.length()时，会出现此异常。
例 1:
这里，在这个例子中，解析后的字符序列的有符号整数值被返回。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)throws NumberFormatException
{
CharSequence s1 = "332";
CharSequence s2 = "-442";
int radix = 8;
//returns the signed Integer value of the entered string in accordance with the radix and beginning and end index
int res1=Integer.parseInt(s1, 0,1,radix);
System.out.println(res1);
int res2=Integer.parseInt(s2,0,2,radix);
System.out.println(res2);
}
}
3
-4
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.Integer;
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter value");
Scanner sc = new Scanner(System.in);
CharSequence s1 = sc.nextLine();
System.out.println("Enter radix");
int radix = sc.nextInt();
System.out.println("Enter start index");
int si =sc.nextInt();
System.out.println("Enter end index");
int ei = sc.nextInt();
//returns the signed Integer value of the entered string in accordance with the radix and beginning and end index
int res1=Integer.parseInt(s1,si,ei,radix);
System.out.println(res1);
}
catch(Exception e)
{
System.out.println("Cannot parse this value");
}
}
}
输入值
505
输入基数
8
输入起始索引
0
输入结束索引
2
40
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T10】输入值
595
输入基数
2
输入起始索引
0
输入结束索引
4
无法解析此值
- T10】输入值
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Java Integer.parseInt(String)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-parseint-string-val-method
Java parseInt(String s)方法是java.lang包的Integer类的一部分。此方法用于将字符串值解析为带符号的十进制整数值。
必须注意的是，除了用于定义整数符号的第一个字符之外，字符串中传递的字符必须都是十进制的。可以是 ASCII 减号“-”符号来表示负值，也可以是 ASCII 加号“+”符号来表示正值。
语法:
public static int parseInt(String s) throws NumberFormatException
参数:
传递的参数是字符串值，其带符号的十进制整数对象将被返回。
返回:
返回作为参数传递的字符串值的带符号十进制整数对象。
例 1:
这里，传递了两个字符串，并作为它们各自的带符号十进制整数对象返回。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
String s1 = "23";
String s2 = "-23";
int n1 = Integer.parseInt(s1); //converts the passed string as signed positive integer
int n2 = Integer.parseInt(s2); //converts the passed string as signed negative integer
System.out.println("Equivalent Integer object is : " + n1);
System.out.println("Equivalent Integer object is : " + n2);
}
}
等效整数对象为:23
等效整数对象为:-23
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.Integer;
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter Value");
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int n = Integer.parseInt(s); //converts the passed string as signed integer
System.out.println("Equivalent Integer object is : " + n);
}
catch(Exception e)
{
System.out.println("Invalid Input!!");
}
}
}
输入值
287
等效整数对象为:287
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4】输入值
-456
等效整数对象为:-456
- T4】输入值
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入值
0x567
无效！！
- *输入值
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.parseInt(String, int)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-parseint-string-int-radix-method
Java parseInt(String s, int radix)方法是java.lang包的Integer类的一部分。此方法用于将字符串值解析为作为参数传递的指定整数基数值中的带符号十进制整数对象。
必须注意的是，除了用于定义整数符号的第一个字符之外，字符串中传递的字符必须都是十进制的。它可以是 ASCII 减号“-”来表示负值，也可以是 ASCII 加号“+”来表示正值。
语法:
public static int parseInt (String s, int radix)
参数:
传递的参数是要返回其带符号十进制整数对象的字符串值和将根据其解析输入字符串的整数基数值。
例外:
NumberFormatException:当输入字符串不可解析时，出现此异常。
返回:
根据基数值，以字符串值的带符号十进制整数对象的形式返回作为参数传递的值。
例 1:
这里，根据传递的整数基数，返回字符串值的带符号十进制整数表示。
import java.lang.Integer;
public class StudyTonight {
public static void main(String[] args) throws NumberFormatException {
String s1 = "603";
String s2 = "-603";
int radix = 16;
System.out.print("\nEntered value and Base value is: " + s1 + " and " + radix);
//returns the signed Integer object of the entered string in accordance with the radix
System.out.println("\nEquivalent Integer object is " + Integer.parseInt(s1, radix));
System.out.print("\nEntered value and Base value is: " + s2 + " and " + radix);
//returns the signed Integer object of the entered string in accordance with the radix
System.out.println("\nEquivalent Integer object is " + Integer.parseInt(s2, radix));
}
}
输入值和基础值为:603 和 16
等效整数对象为 1539
输入值和基础值为:-603 和 16
等效整数对象为-1539
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value: ");
Scanner sc = new Scanner(System. in );
String s = sc.nextLine();
System.out.print("Enter the radix: ");
int radix = sc.nextInt();
//parse the string value into signed value with respect to radix
System.out.println("Equivalent Integer object : " + Integer.parseInt(s, radix));
}
catch(NumberFormatException e) {
System.out.println("Invalid Input!!");
}
}
}
输入数值:57
输入基数:16
等效整数对象:87
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4
输入数值:-37
输入基数:16
等效整数对象:-55
*********************输入数值:0x679
输入基数:2
无效输入！！
- T4
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.parseUnsignedInt(CharSequence, int, int, int)方法
Java parseUnsignedInt(CharSequence s, int beginText, int endText, int radix)方法是java.lang包的Integer类的一部分。根据从传递的起始索引开始并扩展到传递的(结束索引- 1)的整数基数值分析传递的字符序列后，此方法返回等效的无符号整数。该方法没有采取措施防止CharSequence在解析时发生变异。
语法:
public static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix)
参数:
s:需要解析的字符序列。
beginIndex:开始解析的字符序列的索引。
endIndex:字符序列的索引，直到解析将扩展到的地方。
radix:传递字符序列所依据的整数值。
返回:
根据从开始索引开始并延伸到结束索引-1 的整数基数，返回解析字符序列后获得的等效无符号整数值。
例外:
NullPointerException:当输入字符为空时，出现此异常。
NumberFormatException:当输入字符序列不可解析时，出现此异常。
IndexOutOfBoundsException:当开始索引为负或者开始索引值大于结束索引值或者结束索引值大于s.length()时，出现此异常。
例 1:
这里，返回解析后的字符序列的无符号整数值。
import java.lang.Integer;
public class StudyTonight {
public static void main(String[] args) throws NumberFormatException {
CharSequence s1 = "332";
CharSequence s2 = "442";
int radix = 8;
//returns the unsigned Integer value of the entered string in accordance with the radix and beginning and end index
int res1 = Integer.parseUnsignedInt(s1, 0, 1, radix);
System.out.println(res1);
int res2 = Integer.parseUnsignedInt(s2, 0, 2, radix);
System.out.println(res2);
}
}
3
36
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.Integer;
import java.util.Scanner;
public class StudyTonight {
public static void main(String[] args) {
try {
System.out.println("Enter value");
Scanner sc = new Scanner(System. in );
CharSequence s1 = sc.nextLine();
System.out.println("Enter radix");
int radix = sc.nextInt();
System.out.println("Enter start index");
int si = sc.nextInt();
System.out.println("Enter end index");
int ei = sc.nextInt();
//returns the unsigned Integer value of the entered string in accordance with the radix and beginning and end index
int res1 = Integer.parseUnsignedInt(s1, si, ei, radix);
System.out.println(res1);
}
catch(Exception e) {
System.out.println("Cannot parse this value");
}
}
}
输入值
501
输入基数
8
输入起始索引
0
输入结束索引
2
40
输入值
-45
输入基数
8
输入起始索引
0
输入结束索引
1
无法解析此值
Java Integer.parseUnsignedInt(String)方法
原文：https://www.studytonight.com/java-wrapper-class/java-parseunsignedint-string-method
Java parseUnsignedInt(String s)方法是java.lang包的Integer类的一部分。此方法用于将字符串值解析为无符号十进制整数对象。
必须注意的是，除了用于定义整数符号的第一个字符之外，字符串中传递的字符必须都是十进制的。ASCII 加号“+”用于描述正值。
语法:
public static int parseUnsignedInt(String s) throws NumberFormatException
参数:
传递的参数是要返回其无符号十进制整数对象的字符串值。
返回:
返回作为参数传递的字符串值的无符号十进制整数对象。
例 1:
这里，传递了两个字符串，并作为它们各自的无符号十进制整数对象返回。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
String s1 = "23";
String s2 = "132";
int n1 = Integer.parseUnsignedInt(s1); //converts the passed string as unsigned integer
int n2 = Integer.parseUnsignedInt(s2); //converts the passed string as unsigned integer
System.out.println("Equivalent Integer object is : " + n1);
System.out.println("Equivalent Integer object is : " + n2);
}
}
等效整数对象为:23
等效整数对象为:132
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.Integer;
import java.util.Scanner;
public class StudyTonight {
public static void main(String[] args) {
try {
System.out.println("Enter Value");
Scanner sc = new Scanner(System. in );
String s = sc.nextLine();
int n = Integer.parseUnsignedInt(s); //converts the passed string as unsigned integer
System.out.println("Equivalent Integer object is : " + n);
}
catch(Exception e) {
System.out.println("Invalid Input!!");
}
}
}
输入值
45
等效整数对象为:45
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4】输入值
-34
无效输入！！
- T4】输入值
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.parseUnsignedInt(String,int)方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-parseunsignedint-string-int-method
Java parseUnsignedInt(String s,int radix)方法是java.lang包的Integer类的一部分。此方法用于将字符串值解析为作为参数传递的指定整数基数值中的无符号十进制整数。
必须注意的是，除了用于定义整数符号的第一个字符之外，字符串中传递的字符必须都是十进制的。ASCII 加号“+”用于描述正值。
语法:
public static int parseUnsignedInt (String s, int radix)
参数:
传递的参数是要返回其无符号十进制整数对象的字符串值和将根据其解析输入字符串的整数基数值。
例外:
NumberFormatException : 当输入字符串不可解析时，会出现此异常。
返回:
根据基数值，返回作为参数传递的字符串值的无符号十进制整数对象的值。
例 1:
这里，根据传递的整数基数，返回字符串值的无符号十进制整数表示。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)throws NumberFormatException
{
String s1 = "603";
String s2 = "834";
int radix = 16;
System.out.print("\nEntered value and Base value is: " + s1 + " and " + radix);
//returns the unsigned Integer object of the entered string in accordance with the radix
System.out.println("\nEquivalent Integer object is " + Integer.parseUnsignedInt(s1, radix));
System.out.print("\nEntered value and Base value is: " + s2 + " and " + radix);
//returns the unsigned Integer object of the entered string in accordance with the radix
System.out.println("\nEquivalent Integer object is " + Integer.parseUnsignedInt(s2, radix));
}
}
输入值和基础值为:603 和 16
等效整数对象为 1539
输入值和基础值为:834 和 16
等效整数对象为 2100
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value: ");
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
System.out.print("Enter the radix: ");
int radix = sc.nextInt();
System.out.println("Equivalent Integer object : " +Integer.parseUnsignedInt(s,radix)); //parse the string value into unsigned value with respect to radix
}
catch(NumberFormatException e)
{
System.out.println("Invalid Input!!");
}
}
}
输入数值:744
输入基数:16
等效整数对象:1860
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T4】输入数值:-234
输入基数:8
无效输入！！
- T4】输入数值:-234
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.reverse()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-reverse-method
Java reverse()方法是java.lang包的 Integer 类的一部分。此方法用于返回通过反转传递的整数值的二进制补码表示的位的顺序而获得的值。
语法:
public static int reverse(int i)
参数:
传递的参数是一个整数值，其二进制等价值将被反转。
返回:
通过反转传递的参数的二进制补码表示的位的顺序而获得的值。
例 1:
这里，为了更好地理解该方法，取一个正数和一个负数。Integer.toBinaryString()方法用于表示数字的二进制等价形式。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int a = 202;
int b = -50;
System.out.println("Original Number = " + a);
System.out.println("Binary Representation is = " + Integer.toBinaryString(a));
System.out.println("Number after reversal " + Integer.reverse(a));//reversal of the number
System.out.println("\n Original Number = " + b);
System.out.println("Binary Representation is = " + Integer.toBinaryString(b));
System.out.println("Number after reversal = " + Integer.reverse(b));
}
}
原数= 202
二进制表示为= 11001010
反转后数 1392508928
原数= -50
二进制表示为= 11111111111111111111001110
反转后数= 1946157055
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter Original Value ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println("Actual Number = " + i);
System.out.println("Binary Representation = " + Integer.toBinaryString(i)); // returns the integer value into its binary equivalent
System.out.println("After reversing = " + Integer.reverse(i)); //returns the value obtained by reversal of bits
}
catch(Exception e)
{
System.out.println("Invalid Input");
}
}
}
输入原值 78
实际数值= 78
二进制表示= 1001110
换向后= 1912602624
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入原值-98
实际数值= -98
二进制表示= 111111111111111110011110
换向后= 21111111111111110
- *输入原值-98
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.remainderUnsigned()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-remainderunsigned-method
Java remainderUnsigned()方法属于Integer类。此方法用于返回第一个参数除以第二个参数得到的余数(无符号)。结果，即余数总是作为无符号值。
语法:
public static int remainderUnsigned(int dividend, int divisor)
参数:
传递的参数将是int dividend将被划分和 int divisor将进行划分过程.
返回:
第一个参数(即被除数)除以第二个参数(即除数)时的无符号余数。
例 1:
这里，正常的除法过程发生在所有整数都有符号的时候。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int a = 100;
int b = 5;
int c = 3;
System.out.println("Remainder of\t" + a+ "/" +b+ "\t is \t" +Integer.remainderUnsigned(a, b));
System.out.println("Remainder of\t" + a+ "/" +c+ "\t is \t" +Integer.remainderUnsigned(a, c));
}
}
100/5 的余数为 0
100/3 的余数为 1
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the Dividend and Divisor ");
Scanner sc = new Scanner(System.in);
int Dividend = sc.nextInt();
int Divisor = sc.nextInt();
int result = Integer.remainderUnsigned(Dividend, Divisor); //return the unsigned remainder
System.out.println("Remainder is: "+result);
}
catch(Exception e)
{
System.out.println("Invalid Input!!");
}
}
}
输入被除数和除数 78 9
余数为:6
***************输入被除数和除数-56 9
余数为:2
***************输入被除数和除数 100 0
无效输入！！
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.reverseBytes()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-reversebytes-method
Java reverseBytes()方法是java.lang包的 Integer 类的一部分。此方法用于返回通过反转传递的整数值的二进制补码表示的字节顺序而获得的值。
语法:
public static int reverseBytes(int i)
参数:
传递的参数是其字节要反转的整数值。
返回:
通过反转传递的参数的二进制补码表示的字节顺序获得的值。
例 1:
这里，为了更好地理解该方法，取一个正数和一个负数。Integer.toBinaryString()方法用于以二进制等价形式表示数字。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
int a = 342;
int b = -23;
System.out.println("Original Number = " + a);
//converts number to equivalent binary string
System.out.println("Binary Representation is = " + Integer.toBinaryString(a));
//reversal of the bytes
System.out.println("Number after reversal " + Integer.reverseBytes(a));
System.out.println("\n Original Number = " + b);
System.out.println("Binary Representation is = " + Integer.toBinaryString(b));
System.out.println("Number after reversal = " + Integer.reverseBytes(b));
}
}
原数= 342
二进制表示为= 101010110
反转后数 1442906112
原数= -23
二进制表示为= 11111111111111111101001
反转后数= -369098753
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter Original Value ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println("Actual Number = " + i);
// returns the integer value into its binary equivalent
System.out.println("Binary Representation = " + Integer.toBinaryString(i));
//returns the value obtained by reversal of bytes
System.out.println("After reversing = " + Integer.reverseBytes(i));
}
catch(Exception e)
{
System.out.println("Invalid Input");
}
}
}
输入原值 54
实际数值= 54
二进制表示= 110110
换向后= 905969664
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T5】输入原值-43
实际数值= -43
二进制表示= 11111111111111111010101
换向后=-7041
- T5】输入原值-43
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.rotateLeft()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-rotateleft-method
Java rotateLeft()方法是java.lang包的Integer类的一部分。此方法用于返回通过将作为参数传递的数字的二进制等价形式的二进制补码向左(即向高阶)旋转参数中指定的距离而获得的值。
该方法基于位移位操作，其中二进制数的所有位被向左或向右移位到一定数量的位置。例如，rotateLeft(10, 1)指的是 10 的二进制等效值向左旋转一位。 10 的等价二进制为 00001010 ，左移 1 位转换为 00010100 (即等于 20)。
语法:
public static int rotateLeft(int i, int distance)
参数:
传递的参数是整数值，指定要旋转的二进制等价位，以及指定要旋转的位数的 int 距离。
返回:
返回通过将作为参数传递的数字的二进制等价形式的二进制补码向左(即向高阶)旋转方法中传递的距离而获得的值。
例 1:
这里，为了更好地理解该方法，取一个正数和一个负数。Integer.toBinaryString()方法用于以二进制等价形式表示数字。
import java.lang.*;
public class StudyTonight
{
public static void main(String[] args)
{
int n1 = 4;
int n2 = -4;
int val = 3;
System.out.println("Binary equivalent is : " + Integer.toBinaryString(n1));
for(int i = 0; i < val; i++)
{
n1 = Integer.rotateLeft(n1, val); //returns the value after rotation
System.out.println(n1);
}
System.out.println("Binary equivalent is : " + Integer.toBinaryString(n2));
for(int i = 0; i < val; i++)
{
n2 = Integer.rotateLeft(n2, val); //returns the value after rotation
System.out.println(n2);
}
}
}
二进制等值为:100
32
256
2048
二进制等值为:1111111111111111111111100
-25
-193
-1537
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.*;
import java.util.*;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the value and distance");
Scanner sc = new Scanner (System.in);
int n = sc.nextInt();
int val = sc.nextInt();
System.out.println("Binary equivalent is : " + Integer.toBinaryString(n));
for(int i = 0; i < val; i++)
{
n = Integer.rotateLeft(n, val); //returns the value after rotation
System.out.println(n);
}
}
catch(Exception e)
{
System.out.println("Invalid Input");
}
}
}
输入数值和距离
5 4
二进制等效值为:101
80
1280
20480
327680
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入数值和距离
-30 4
二进制等效值为:11111111111111111111100010
- *输入数值和距离
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.rotateRight()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-rotateright-method
Java rotateRight()方法是java.lang包的Integer类的一部分。此方法用于返回通过将作为参数传递的数字的二进制等价形式的二进制补码向右(即向低阶)旋转参数中指定的距离而获得的值。
这种方法也是基于比特移位操作，其中二进制数的所有比特被向左或向右移位到一定数量的位置。例如，rotateRight(10,1) 指的是 10 的二进制表示向右旋转一位。10 的等价二进制数是 00001010，通过向左移位 1 位，它将被转换为 00000101(即等于 5)。
语法:
public static int rotateRight(int i, int distance)
参数:
传递的参数是整数值，指定要旋转的二进制等价位，以及指定要旋转的位数的 int 距离。
返回:
返回通过将作为参数传递的数字的二进制等价形式的二进制补码向右(即向低阶)旋转方法中传递的距离而获得的值。
例 1:
这里，为了更好地理解该方法，取一个正数和一个负数。Integer.toBinaryString()方法用于以二进制等价形式表示数字。
import java.lang.*;
public class StudyTonight
{
public static void main(String[] args)
{
int n1 = 8;
int n2 = -8;
int val = 3;
System.out.println("Binary equivalent is : " + Integer.toBinaryString(n1));
for(int i = 0; i < val; i++)
{
n1 = Integer.rotateRight(n1, val); //returns the value after rotation
System.out.println(n1);
}
System.out.println("Binary equivalent is : " + Integer.toBinaryString(n2));
for(int i = 0; i < val; i++)
{
n2 = Integer.rotateRight(n2, val); //returns the value after rotation
System.out.println(n2);
}
}
}
二进制等值为:1000
1
536870912
67108864
二进制等值为:11111111111111111111111000
536870911
-469762049
-58720257
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等效的输出。
import java.lang.*;
import java.util.*;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.println("Enter the value and distance");
Scanner sc = new Scanner (System.in);
int n = sc.nextInt();
int val = sc.nextInt();
System.out.println("Binary equivalent is : " + Integer.toBinaryString(n));
for(int i = 0; i < val; i++)
{
n = Integer.rotateRight(n, val); //returns the value after rotation
System.out.println(n);
}
}
catch(Exception e)
{
System.out.println("Invalid Input");
}
}
}
输入数值和距离
6 3
二进制等效值为:110
-1073741824
402653184
50331648
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- *输入数值和距离
-6 3
二进制等效值为:11111111111111111111111111111111111111111111111111111111111111111111111111111
- *输入数值和距离
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
实时示例:
在这里，您可以测试实时代码示例。您可以为不同的值执行示例，甚至可以编辑和编写您的示例来测试 Java 代码。
Java Integer.shortValue()方法
原文：https://www.studytonight.com/java-wrapper-class/java-integer-shortvalue-method
Java shortValue()方法属于 java.lang 包的Integer类。此方法在缩小图元转换(将较高数据类型转换为较低数据类型)后，返回整数对象的短等效物。
简而言之，该方法用于将整数对象转换为短值。
语法:
public short shortValue()
参数:
此方法中没有传递任何参数。
返回:
Short类型对象的数字等价物在转换后创建。
例 1:
这里，使用shortValue()方法，整数值被转换成其数值的短等价物。
import java.lang.Integer;
public class StudyTonight
{
public static void main(String[] args)
{
//converting integer object into short
Integer x = 99;
short i=x.shortValue();
System.out.println(" Equivalent short value is " +i);
Integer y = 23;
short d = y.shortValue();
System.out.println(" Equivalent short value is " +d);
}
}
等值短值为 99
等值短值为 23
例 2:
这里有一个用户定义的例子，任何使用这段代码的人都可以输入自己选择的值，并获得等价的短值。
import java.util.Scanner;
public class StudyTonight
{
public static void main(String[] args)
{
try
{
System.out.print("Enter the value to be converted : ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Integer n = i ;
short val = n.shortValue();
System.out.println("Short Value is: " + val);
}
catch(Exception e)
{
System.out.println("not a valid integer");
}
}
}
输入需要转换的数值:54
短数值为:54
