「java函数有哪些」java函数方法有什么区别

admin 2023-01-17 19:12:11 317

本篇文章给大家谈谈java函数有哪些，以及java函数方法有什么区别对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、总结Java Web中几个函数的作用
2、java中都有哪些函数
3、java集合类哪个函数可以
4、java常用函数方法
5、JAVA中求绝对值的函数是什么？
6、Java初学者应掌握哪些常用的系统函数？

总结Java Web中几个函数的作用

一 ServletContext():(zz)

Servlet容器在启动时会加载Web应用并为每个Java Web应用创建唯一的ServletContext对象可以把ServletContext看成是一个Web应用的服务器端组件的共享内存在ServletContext中可以存放共享数据它提供了个读取或设置共享数据的方法

）setAttribute(Stringname Objectobject):把一个对象和一个属性名绑定将这个对象存储在ServletContext中

）getAttribute(Stringname):根据指定的属性名返回所绑定的对象

）removeAttribute(Stringname):根据给定的属性名从ServletContext中删除相应的操作

）getAttributeNames():返回Enumeration对象它包含了存储在ServletContext对象中的所有属性名

packagemypack;

importjavax servlet *;

importjava io *;

importjava util *;

publicclassCounterServletextendsHttpServlet

{

publicstaticfinalStringCONTENT_TYPE= text/;charset=GB ;

publicvoidinit(ServletConfigconfig)throwsServletException{

super init(config);

}

publicvoiddoGet(HttpServletRequestrequest HttpServletResponseresponse)throwsServletException IOException{

doPost(request response);

}

publicvoiddoPost(HttpServletRequestrequest HttpServletResponseresponse)throwsServletException IOException{

//获得ServletContext的引用

ServletContextcontext=getServletContext();

//从ServletContext读取count属性

Integercount=(Integer)context getAttribute( count );

//如果count属性还没有设置那么创建count属性初始值为

//oneandaddittotheServletContext

if(count==null){

unt=newInteger( );

ntext setAttribute( count newInteger( ));

}

response setContentType(CONTENT_TYPE);

PrintWriterout=response getWriter();

out println( HTML );

out println( HEADTITLE点击计数/TITLE/HEAD );

out println( BODY );

//输出当前的count属性值

out println( P当前计数是 +count+ /P );

out println( /BODY/HTML );

//创建新的count对象其值增

unt=newInteger(count intValue()+ );

//将新的count属性存储到ServletContent中

ntext setAttribute( count count);

}

publicvoiddestroy(){

}

在web xml中为CounterServlet类加上servlet和servlet mapping元素

servlet

servlet nameCounterServlet/servlet name

servlet classmypack CounterServlet/servlet class

/servlet

servlet mapping

servlet nameCounterServlet/servlet name

url pattern/counter/url pattern

/servlet mapping

测试通过

）刷新页面 count加

）关闭浏览器再打开新浏览器还是在原来基础上加（即便由IE换成Opera）

）如果重启Tomcat服务器再访问CounterServlet 则count又初始化为

）复制helloapp应用改为helloapp 再发布helloapp 通过不同的浏览器窗口分别访问helloapp及helloapp 中的CounterServlet 发现这两个Web应用拥有各自独立的count属性

即ServletContext对象只在Web应用被关闭时才被销毁不同的Web应用 ServletContext各自独立存在

二以前不知道在struts config xml中还可以写数据库的配置现在知道了是可以在struts config xml中下data source标签来进行数据库的配置的

data sources

data sourcekeydata sourcekey= DATASOURCE type= oracle jdbc pool OracleDataSource

! 说明

set propertypropertyset propertyproperty= description value= ExampleDataSourceConfiguration /

! 所用的JDBC驱动类必须

set propertypropertyset propertyproperty= driverClassName value= oracle jdbc driver OracleDriver /

! 所用的JDBC的URL 必须

set propertypropertyset propertyproperty= URL value= jdbc:oracle:thin:@ : ;DatabaseName=ITDBT /

! 同时打开的最大连接数缺省值为可选

set propertypropertyset propertyproperty= maxActive value= /

! 同时打开的最小连接数缺省值为可选

set propertypropertyset propertyproperty= minCount value= /

! 连接到数据库的用户名必须

set propertypropertyset propertyproperty= user value= vendorda /

! 连接到数据库的密码必须

set propertypropertyset propertyproperty= password value= vendorda /

! 是否自动MIT

set propertypropertyset propertyproperty= autoCommit value= true /

/data source

/data sources

在这个里面配置好之后如果想要建立一个数据库的链接就可以这样写

DataSourcedataSource=(DataSource)servlet getServletContext() getAttribute(Action DATA_SOURCE_KEY);

Connectionconnection=dataSource getConnection();

三 ActionMessage的作用（zz）

ActionMessage ActionMessages saveMessages() saveErrors() 之间的关系及用法

ActionMessage功能是用来产生STRUTS消息的包括正常消息和错误消息注（原有ActionError方法来产生错误消息但已废弃但仍可使用）例 ActionMessage(key object);其中key为在appication properties中指的key值 object为消息中要传入的参数这里实现了动态传入如果要传多个参数时 object处可以改为数组

ActionMessages功能是作为容器(map)来存ActionMessage的例 :ActionMessagesams=newActionMessages() ams add（ id ActionMessage)

saveErrors功能是用来存储ActionMessages 例 saveErrors(ActionMessages scope)这里有个隐性的error_key作为KEY与ActionMessages对应 scope值为:application session request page 默认为page范围

saveMessages功能是用来存储ActionMessages 例 saveMessages(ActionMessages scope)这里有个隐性的message_key作为KEY与ActionMessages对应 scope值为:application session request page 默认为page范围

取出ActionMessage消息STRUTS提供了两种标签

:errors/意思是从page范围(范围由小到大从page到application)开始以error_key为key寻找ActionMessages 要取具体的ActionMessage可以用:errorsproperty= id /

:messageid= var /bean:writename= var /意思是迭代找出所有ActionMessage赋值给var 然后通过bean标签输出要取具体的ActionMessage可以用:messageid= var property= id /bean:writename= var / 这里:message标签有个默认message属性它的默认值为false 代表以error_key为key取出ActionMessages 设为true时代表以message_key为key取出ActionMessages 它与:errors/的主要区别是它可以取正常消息或错误消息（即以error_key或message_key为KEY）通过设置message属性true或false来实现

lishixinzhi/Article/program/Java/hx/201311/26510

java中都有哪些函数

Java里的函数多的数不过来，常用的函数有equals(),toString(),compare(),分别用于比较是否相等、输出对象信息、比较两个对象。函数的功能是用于完成某些需要完成的任务。

java集合类哪个函数可以

java集合里面的函数

java集合里面的函数_java集合【1】——— 从集合接口框架说起

百里方欣

原创

关注

0点赞·155人阅读

(一) java集合分类

之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue.主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说java里面的集合类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列集合的规范，每次只能存储一个元素，而Map接口定义了双列集合的规范，每次能存储一对元素。

Iterable接口:主要是实现遍历功能

Collection接口: 允许重复

Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。

List接口：有序且可重复，可以根据元素的索引来访问集合中的元素。

Queue接口：队列集合

Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。

整个接口框架关系如下(来自百度百科)：

(1) Iterable接口

1. 内部定义的方法

java集合最源头的接口，实现这个接口的作用主要是集合对象可以通过迭代器去遍历每一个元素。

源码如下：

// 返回一个内部元素为T类型的迭代器(JDK1.5只有这个接口)

Iterator iterator();

// 遍历内部元素，action意思为动作，指可以对每个元素进行操作(JDK1.8添加)

default void forEach(Consumer super T action) {}

// 创建并返回一个可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。

default Spliterator spliterator() {

return Spliterators.spliteratorUnknownSize(iterator(), 0);

}

从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Java 8 新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。

下面我们分别展示三个接口的调用：

1.1 iterator方法

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

// 返回迭代器

Iterator iterator=list.iterator();

// hashNext可以判断是否还有元素

while(iterator.hasNext()){

//next()作用是返回当前指针指向的元素,之后将指针移向下个元素

System.out.println(iterator.next());

}

当然也可以使用for-each loop方式遍历

for (String item : list) {

System.out.println(item);

}

但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：

public class IterableTest {

public IterableTest() { }

public static void main(String[] args) {

iteratorHasNext();

}

public static void iteratorHasNext() {

List list = new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

Iterator iterator = list.iterator();

Iterator var2 = list.iterator();

while(var2.hasNext()) {

String item = (String)var2.next();

System.out.println(item);

}

需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败【fast-fail】机制。

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

for (String item : list) {

if(item.equals("Jam")){

list.remove(item);

}

System.out.println(item);

}

从下面的错误我们可以看出，第一个元素是有被打印出来的，也就是remove操作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。

Jam

Exception in thread "main" java.util.ConcurrentModificationException

at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)

at java.util.ArrayList$Itr.next(ArrayList.java:859)

at IterableTest.iteratorHasNext(IterableTest.java:15)

at IterableTest.main(IterableTest.java:7)

1.2 forEach方法

其实就是把对每一个元素的操作当成了一个对象传递进来，对每一个元素进行处理。

default void forEach(Consumer super T action) {

Objects.requireNonNull(action);

for (T t : this) {

action.accept(t);

}

```java

当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在java8中参数是`java.util.function.Consumer`,可以称为**消费行为**或者说**动作**类型。

```java

list.forEach(x - System.out.print(x));

同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。

public class ConsumerTest {

public static void main(String[] args) {

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

MyConsumer myConsumer = new MyConsumer();

Iterator it = list.iterator();

list.forEach(myConsumer);

}

static class MyConsumer implements Consumer {

@Override

public void accept(Object t) {

System.out.println("自定义打印：" + t);

}

输出的结果：

自定义打印：Jam

自定义打印：Jane

自定义打印：Sam

1.3 spliterator方法

这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，java默认在集合框架中提供了一个默认的Spliterator实现，底层也就是Stream.isParallel()实现的，我们可以看一下源码：

// stream使用的就是spliterator

default Stream stream() {

return StreamSupport.stream(spliterator(), false);

}

default Spliterator spliterator() {

return Spliterators.spliterator(this, 0);

}

public static Stream stream(Spliterator spliterator, boolean parallel) {

Objects.requireNonNull(spliterator);

return new ReferencePipeline.Head(spliterator,

StreamOpFlag.fromCharacteristics(spliterator),

parallel);

}

使用的方法如下：

public static void spliterator(){

List list = Arrays.asList("1", "2", "3","4","5","6","7","8","9","10");

// 获取可迭代器

Spliterator spliterator = list.spliterator();

// 一个一个遍历

System.out.println("tryAdvance: ");

spliterator.tryAdvance(item-System.out.print(item+" "));

System.out.println("\n-------------------------------------------");

// 依次遍历剩下的

System.out.println("forEachRemaining: ");

spliterator.forEachRemaining(item-System.out.print(item+" "));

System.out.println("\n------------------------------------------");

// spliterator1:0~10

Spliterator spliterator1 = list.spliterator();

// spliterator1:6~10 spliterator2:0~5

Spliterator spliterator2 = spliterator1.trySplit();

// spliterator1:8~10 spliterator3:6~7

Spliterator spliterator3 = spliterator1.trySplit();

System.out.println("spliterator1: ");

spliterator1.forEachRemaining(item-System.out.print(item+" "));

System.out.println("\n------------------------------------------");

System.out.println("spliterator2: ");

spliterator2.forEachRemaining(item-System.out.print(item+" "));

System.out.println("\n------------------------------------------");

System.out.println("spliterator3: ");

spliterator3.forEachRemaining(item-System.out.print(item+" "));

}

tryAdvance() 一个一个元素进行遍历

forEachRemaining() 顺序地分块遍历

trySplit()进行分区形成另外的 Spliterator，使用在并行操作中，分出来的是前面一半，就是不断把前面一部分分出来

结果如下：

tryAdvance:

1 2

-------------------------------------------

forEachRemaining:

3 4 5 6 7 8 9 10

------------------------------------------

spliterator1:

8 9 10

------------------------------------------

spliterator2:

1 2 3 4 5

------------------------------------------

spliterator3:

6 7

还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。

2. Collection接口 extend Iterable

Collection接口可以算是集合类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的差异比较大。

2.1 内部定义的方法

源码如下：

boolean add(Object o) //添加元素

boolean remove(Object o) //移除元素

boolean addAll(Collection c) //批量添加

boolean removeAll(Collection c) //批量移除

void retainAll(Collection c) // 移除在c中不存在的元素

void clear() //清空集合

int size() //集合大小

boolean isEmpty() //是否为空

boolean contains(Object o) //是否包含在集合中

boolean containsAll(Collection c) //是否包含所有的元素

Iterator iterator() // 获取迭代器

Object[] toArray() // 转成数组

default boolean removeIf(Predicate super E filter) {} // 删除集合中复合条件的元素，删除成功返回true

boolean equals(Object o)

int hashCode()

default Spliterator spliterator() {} //获取可分割迭代器

default Stream stream() {} //获取流

default Stream parallelStream() {} //获取并行流

里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3...，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。

List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

list.parallelStream()

.forEach(out::println);

2.2 继承Collection的主要接口

graph LR;

Collection --List-有顺序,可重复

List-有顺序,可重复 --LinkedList-使用链表实现,线程不安全

List-有顺序,可重复 --ArrayList-数组实现,线程不安全

List-有顺序,可重复 --Vector-数组实现,线程安全

Vector-数组实现,线程安全 --Stack-堆栈,先进后出

Collection--Set-不可重复,内部排序

Set-不可重复,内部排序--HashSet-hash表存储

HashSet-hash表存储--LinkHashSet-链表维护插入顺序

Set-不可重复,内部排序--TreeSet-二叉树实现,排序

Collection--Queue-队列,先进先出

2.2.1 List extend Collection

继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。

最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的操作，唯一不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList操作的效率会比Vector好一些。

里面是接口定义的方法：

int size(); //获取大小

boolean isEmpty(); //判断是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); // 转化成为数组(对象)

T[] toArray(T[] a); // 转化为数组(特定位某个类)

boolean add(E e); //添加

boolean remove(Object o); //移除元素

boolean containsAll(Collection c); // 是否包含所有的元素

boolean addAll(Collection extends E c); //批量添加

boolean addAll(int index, Collection extends E c); //批量添加，指定开始的索引

boolean removeAll(Collection c); //批量移除

boolean retainAll(Collection c); //将c中不包含的元素移除

default void replaceAll(UnaryOperator operator) {}//替换

default void sort(Comparator super E c) {}// 排序

void clear();//清除所有的元素

boolean equals(Object o);//是否相等

int hashCode(); //计算获取hash值

E get(int index); //通过索引获取元素

E set(int index, E element);//修改元素

void add(int index, E element);//在指定位置插入元素

E remove(int index);//根据索引移除某个元素

int indexOf(Object o); //根据对象获取索引

int lastIndexOf(Object o); //获取对象元素的最后一个元素

ListIterator listIterator(); // 获取List迭代器

ListIterator listIterator(int index); // 根据索引获取当前的位置的迭代器

List subList(int fromIndex, int toIndex); //截取某一段数据

default Spliterator spliterator(){} //获取可切分迭代器

上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。

操作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfBoundsException。

说起List的实现子类：

ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List集合。线程不安全。

LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。

Vector：和ArrayList差不多，但是是线程安全的，即同步。

2.2.2 Set extend Collection

Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。

下面是源码方法：

int size(); //获取大小

boolean isEmpty(); //是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); //转化成为数组

T[] toArray(T[] a); //转化为特定类的数组

boolean add(E e); //添加元素

boolean remove(Object o); //移除元素

boolean containsAll(Collection c); //是否包含所有的元素

boolean addAll(Collection extends E c); //批量添加

boolean retainAll(Collection c); //移除所有不存在于c集合中的元素

boolean removeAll(Collection c); //移除所有在c集合中存在的元素

void clear(); //清空集合

boolean equals(Object o); //是否相等

int hashCode(); //计算hashcode

default Spliterator spliterator() {} //获取可分割迭代器

主要的子类：

HashSet

允许空值

通过HashCode方法计算获取hash值，确定存储位置，无序。

LinkedHashSet

HashSet的子类

有顺序

TreeSet

如果无参数构建Set，则需要实现Comparable方法。

亦可以创建时传入比较方法，用于排序。

2.2.3 Queue extend Collection

队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。

下面是源码：

boolean add(E e); //插入一个元素到队列，失败时返回IllegalStateException (如果队列容量不够)

boolean offer(E e); //插入一个元素到队列，失败时返回false

E remove(); //移除队列头的元素并移除

E poll(); //返回并移除队列的头部元素，队列为空时返回null

E element(); //返回队列头元素

E peek(); //返回队列头部的元素，队列为空时返回null

主要的子接口以及实现类有：

Deque(接口):Queue的子接口，双向队列，可以从两边存取

ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中

AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法

PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，

BlockingQueue：在java.util.concurrent包中，阻塞队列，满足当前无法处理的操作。

(2) Map接口

定义双列集合的规范Map，每次存储一对元素，即key和value。

key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。

key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。

下面的源码的方法：

V put(K key, V value); // 添加元素

V remove(Object key); // 删除元素

void putAll(Map extends K, ? extends V m); // 批量添加

void clear() // 移除所有元素

V get(Object key); // 通过key查询元素

int size(); // 查询集合大小

boolean isEmpty(); // 集合是否为空

boolean containsKey(Object key); // 是否包含某个key

boolean containsValue(Object value); // 是否包含某个value

Set keySet(); // 获取所有key的set集合

Collection values(); // 获取所有的value的set集合

Set entrySet(); // 返回键值对的set，每一个键值对是一个entry对象

boolean equals(Object o); // 用于比较的函数

int hashCode(); // 计算hashcode

default V getOrDefault(Object key, V defaultValue) // 获取key对应的Value，没有则返回默认值()

default void forEach(BiConsumer super K, ? super V action) {} // 遍历

default void replaceAll(BiFunction super K, ? super V, ? extends V function) {} // 批量替换

// 缺少这个key的时候才会添加进去

// 返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value

default V putIfAbsent(K key, V value) {}

default boolean remove(Object key, Object value) {} // 移除元素

default boolean replace(K key, V oldValue, V newValue) {} // 替换

default V replace(K key, V value) {} //替换

// 和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值

default V computeIfAbsent(K key,Function super K, ? extends V mappingFunction) {}

// 和computeIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回

default V computeIfPresent(K key,BiFunction super K, ? super V, ? extends V remappingFunction) {}

// 不管如何都会执行映射函数，返回value

default V compute(K key,BiFunction super K, ? super V, ? extends V remappingFunction) {}

default V merge(K key, V value,BiFunction super V, ? super V, ? extends V remappingFunction) {}

值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个.

Map的常用的实现子类：

HashMap：由数组和链表组成，线程不安全，无序。

LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。

ConcurrentHashMap：线程安全，1.7JDK使用锁分离，每一段Segment都有自己的独立锁，相对来说效率也比较高。JDK1.8抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。

HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。

(二)总结

这些集合原始接口到底是什么？为什么需要？

我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的集合接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千集合世界。

【作者简介】：

秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~

java常用函数方法

Java的一些常用函数,方法总结：

1:数组方面:

数组是一个对象,数组名可以理解和C++里面一样,

1):System.arraycopy(src,srcindex,dst,dstindex,src.length);

2):java.util.Arrays.sort(数组名);//块数排序法进行排序

3):java.util.Arrays.binarySearch(arr,key);//从哪里收,关键值,返回索引.没有的话返回-1

4):java.util.Array.fill(arr,value),设置数组初始值

5):Array.equals(arr1,arr2)//比较两个数组中元素是不是全部相等,是返回true,不是返回false

2:时间方面:

public static String dateToStr(java.util.Date date)

{

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String str = sdf.format(date);

return str;

}

import java.text.SimpleDateFormat;

import java.util.Calendar;

public class DateUtil

{

public static java.util.Date parseDate(String dateStr, String format)

{

java.util.Date date = null;

try

{

java.text.DateFormat df = new java.text.SimpleDateFormat(format);

String dt = dateStr.replaceAll("-", "/");

if ((!dt.equals("")) (dt.length() format.length()))

{

dt += format.substring(dt.length()).replaceAll("[YyMmDdHhSs]", "0");

}

date = (java.util.Date) df.parse(dt);

}

catch (Exception e)

{

}

return date;

}

public static java.util.Date parseDate(String dateStr)

{

return parseDate(dateStr, "yyyy/MM/dd");

}

public static String format(java.util.Date date, String format)

{

String result = "";

try

{

if (date != null)

{

java.text.DateFormat df = new java.text.SimpleDateFormat(format);

result = df.format(date);

}

catch (Exception e)

{

}

return result;

}

public static String format(java.util.Date date)

{

return format(date, "yyyy/MM/dd");

}

public static int getYear(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.get(java.util.Calendar.YEAR);

}

public static int getMonth(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.get(java.util.Calendar.MONTH) + 1;

}

public static int getDay(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.get(java.util.Calendar.DAY_OF_MONTH);

}

public static int getHour(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.get(java.util.Calendar.HOUR_OF_DAY);

}

public static int getMinute(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.get(java.util.Calendar.MINUTE);

}

public static int getSecond(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.get(java.util.Calendar.SECOND);

}

public static long getMillis(java.util.Date date)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTime(date);

return c.getTimeInMillis();

}

public static String getDate(java.util.Date date)

{

return format(date, "yyyy/MM/dd");

}

public static String getTime(java.util.Date date)

{

return format(date, "HH:mm:ss");

}

public static String getDateTime(java.util.Date date)

{

return format(date, "yyyy/MM/dd HH:mm:ss");

}

public static java.util.Date addDate(java.util.Date date, int day)

{

java.util.Calendar c = java.util.Calendar.getInstance();

c.setTimeInMillis(getMillis(date) + ((long) day) * 24 * 3600 * 1000);

return c.getTime();

}

public static int diffDate(java.util.Date date, java.util.Date date1)

{

return (int) ((getMillis(date) - getMillis(date1)) / (24 * 3600 * 1000));

}

public static String getMonthBegin(String strdate)

{

java.util.Date date = parseDate(strdate);

return format(date, "yyyy-MM") + "-01";

}

public static String getMonthEnd(String strdate)

{

java.util.Date date = parseDate(getMonthBegin(strdate));

Calendar calendar = Calendar.getInstance();

calendar.setTime(date);

calendar.add(Calendar.MONTH, 1);

calendar.add(Calendar.DAY_OF_YEAR, -1);

return formatDate(calendar.getTime());

}

public static String formatDate(java.util.Date date)

{

return formatDateByFormat(date, "yyyy-MM-dd");

}

public static String formatDateByFormat(java.util.Date date, String format)

{

String result = "";

if (date != null)

{

try

{

SimpleDateFormat sdf = new SimpleDateFormat(format);

result = sdf.format(date);

}

catch (Exception ex)

{

ex.printStackTrace();

}

return result;

}

Java日期格式化及其使用例子

1 SimpleDateFormat担当重任,怎样格式化都行

import java.util.Date;

import java.text.SimpleDateFormat;

public class Demo

{

public static void main(String[] args)

{

Date now=new Date();

SimpleDateFormat f=newSimpleDateFormat("今天是"+"yyyy年MM月dd日 E kk点mm分");

System.out.println(f.format(now));

f=new SimpleDateFormat("a hh点mm分ss秒");

System.out.println(f.format(now));

}

2 从字符串到日期类型的转换：

import java.util.Date;

import java.text.SimpleDateFormat;

import java.util.GregorianCalendar;

import java.text.*;

publicclass Demo

{

public static void main(String[] args)

{

String strDate="2005年04月22日";

//注意：SimpleDateFormat构造函数的样式与strDate的样式必须相符

SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日");

//必须捕获异常

try

{

Date date=simpleDateFormat.parse(strDate);

System.out.println(date);

}

catch(ParseException px)

{

px.printStackTrace();

}

3 将毫秒数换转成日期类型

import java.util.Date;

import java.text.SimpleDateFormat;

import java.util.GregorianCalendar;

import java.text.*;

public class Demo

{

public static void main(String[] args)

{

long now=System.currentTimeMillis();

System.out.println("毫秒数："+now);

Date dNow=new Date(now);

System.out.println("日期类型："+dNow);

}

4 获取系统时期和时间，转换成SQL格式后更新到数据库

java.util.Date d=new java.util.Date(); //获取当前系统的时间

//格式化日期

new java.text.SimpleDateFormat s= new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String dateStr = s.format(d); //转为字符串

使用RS更新数据库，仍然要用rs.updateString，而不是rs.updateDade。

rs.updateString("regtime",dateStr); //regtime字段为datetime类型的

5 按本地时区输出当前日期

Date myDate = new Date();

System.out.println(myDate.toLocaleString());

输出结果为：

2003-5-30

6 如何格式化小数

DecimalFormat df = new DecimalFormat(",###.00");

double aNumber = 33665448856.6568975;

String result = df.format(aNumber);

Sytem. out.println(result);

输出结果为：

33,665,448,856.66

其他：获取毫秒时间 System.currentTimeMillis();

7 在数据库里的日期只以年-月-日的方式输出

定义日期格式：SimpleDateFormat sdf = new SimpleDateFormat(yy-MM-dd);

sql语句为：String sqlStr = "select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'";

输出：

System.out.println(df.format(rs.getDate("bookDate")));

JAVA中求绝对值的函数是什么？

函数：Math.java。

绝对值函数使用说明：

绝对值函数是JDK中Math.java中的实现方法，其用来得到表达式的绝对值。其实现非常简单，源码如下。

绝对值的特性及其运用：

1、正数的绝对值是其本身。

2、负数的绝对值是其相反数。

3、零的绝对值是其本身。

绝对值：自减函数配合绝对值，先降序再升序。

Java初学者应掌握哪些常用的系统函数？

基本概念：1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why。所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率。2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。5.对象的3个主要特性ehavior---说明这个对象能做什么。tate---当对象施加方法时对象的反映。dentity---与其他相似行为对象的区分标志。每个对象有唯一的indentity 而这3者之间相互影响。6.类之间的关系:use-a :依赖关系has-a :聚合关系is-a :继承关系--例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。例:Data类的构造器叫Dataew Data()---构造一个新对象，且初始化当前时间。Data happyday=new Data()---把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用。构造器特点:构造器可以有0个，一个或多个参数; 构造器和类有相同的名字;一个类可以有多个构造器;构造器没有返回值;构造器总是和new运算符一起使用。8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包。java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。12.多态:在java中，对象变量是多态的.而java中不支持多重继承。13.动态绑定:调用对象方法的机制。(1)编译器检查对象声明的类型和方法名。(2)编译器检查方法调用的参数类型。(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。(4)当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。(5)动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。14.final类:为防止他人从你的类上派生新类，此类是不可扩展的。15.动态调用比静态调用花费的时间要长。16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。例: public abstract string getDescripition17.Java中的每一个类都是从Object类扩展而来的。18.object类中的equal和toString方法。equal用于测试一个对象是否同另一个对象相等。toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示。(toString 方法是一个很重要的方法)19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大校21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大。A.在运行时分析类的能力。B.在运行时探察类的对象。C.实现通用数组操纵代码。D.提供方法对象。而此机制主要针对是工具者而不是应用及程序。反射机制中的最重要的部分是允许你检查类的结构.用到的API有:java.lang.reflect.Field 返回字段。java.reflect.Method 返回方法。java.lang.reflect.Constructor 返回参数。方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。24.接口不是一个类，而是对符合接口要求的类的一套规范。若实现一个接口需要2个步骤:A.声明类需要实现的指定接口。B.提供接口中的所有方法的定义。声明一个类实现一个接口需要使用implements 关键字class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口。25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。例:ActionListener 接口监听。类似的API有:java.swing.JOptionPanejava.swing.Timerjava.awt.Tookit27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。28.内部类:一个内部类的定义是定义在另一个内部的类。原因是:A.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。B.对于同一个包中的其他类来说，内部类能够隐藏起来。C.匿名内部类可以很方便的定义回调。D.使用内部类可以非常方便的编写事件驱动程序。29.代理类(proxy):A.指定接口要求所有代码B.object类定义的所有的方法(toString equals)30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型。

关于java函数有哪些和java函数方法有什么区别的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：java函数有哪些