Java基础与高级建模指南

需积分: 5 7 浏览量更新于2024-07-06 收藏 3.2MB PDF 举报

"Advanced Modeling with Java.pdf 是一本关于在AnyLogic中使用Java进行高级建模的教程，涵盖了Java基础知识和AnyLogic特定的功能。" 在Java基础知识部分，该书详细介绍了以下内容： 1. Java在AnyLogic中的应用：这部分可能讲解了如何在AnyLogic环境中集成和使用Java代码，以及Java如何增强AnyLogic模型的功能。 1.1. 原始数据类型：包括基本的Java数据类型，如int、double、boolean等，它们是构建计算和逻辑的基础。 1.2. 类：Java编程的核心是面向对象，类是对象的蓝图，用于封装数据和行为。 1.3. 变量（局部变量和类字段）：区分在方法内部（局部变量）和类中（类字段）声明的变量，以及它们的作用域和生命周期。 1.4. 函数（方法）：函数是执行特定任务的代码块，可以通过参数接收输入并返回结果。 1.5. 表达式：包括算术表达式、关系和相等表达式、逻辑表达式、字符串表达式和三元条件运算符，这些都是构成程序逻辑的关键部分。 1.6. 语句：涉及不同类型的语句，如声明、函数调用、赋值、if-then-else、switch、for循环、while循环、代码块以及return语句，这些都是控制程序流程的方式。 1.7. Java数组和集合：数组是固定大小的同类型元素序列，而集合是动态存储对象的容器，如ArrayList和LinkedList。 1.8. 注释：编写可读性高的代码，注释是必不可少的，书中可能讲解了单行和多行注释的使用。 1.9. 命名约定：遵循Java的命名规范，如驼峰命名法，有助于提高代码可读性。 1.10. 定位和导航：在大型项目中，了解如何快速定位和访问所需的部分是至关重要的。 1.11. 添加Java类和接口：这部分可能指导读者如何在AnyLogic中创建和导入自定义的Java类和接口，以扩展模型功能。接下来，书本进入AnyLogic特有的函数部分： 2.1. 数学函数：涵盖各种数学运算，如三角函数、指数、对数等，用于模拟中的计算需求。 2.2. 处理数组（type[]）的函数：这些函数可能帮助操作和处理数组，例如查找、排序或修改元素。 2.3. 概率分布：在建模随机事件时，概率分布至关重要。书中可能包括定制分布，以及常见的伯努利、贝塔等分布的用法。 2.3.1. 自定义分布：允许用户创建自己的概率分布，以适应特定的模拟需求。 2.3.2. bernoulli：二项分布，用于表示成功或失败的独立事件。 2.3.3. beta：贝塔分布，常用于连续变量的概率建模，特别是作为其他随机变量的先验分布。 2.3.4. beta(truncated)：截断的贝塔分布，限制了取值范围。这本书提供了在AnyLogic中利用Java进行高级建模的全面指南，无论是对于Java初学者还是有经验的开发者，都能从中受益，提升模型的复杂性和效率。

2022/1/11 上午9:37

Advanced Modeling with Java

127.0.0.1:13091/help/advanced/print.jsp?topic=/../nav/3

16/122

}

return null; //we are here if the order was not found – return null

}

If the return statement is located inside one or several nested loops or if statements, it immediately terminates execution of all of them and exits the

function. If a function does not return a value, you can skip the return at the very end of its body: the function will be exited in its natural way:

void addFriend( Person p ) { //void means no value is returned

if( friends.contains( p ) )

return; //explicit return from the middle of the function

friends.add( p );

//otherwise the function is exited after the last statement – no return is needed

}

1.8. Java arrays and collections

Java offers two types of constructs where you can store multiple values or objects of the same type: arrays and collections (for System Dynamics

models AnyLogic also offers HyperArray, also known as "subscripts", – a special type of collection for dynamic variables).

Array or collection? Arrays are simple constructs with linear storage of fixed size and therefore they can only store a given number of elements.

Arrays are built into the core of Java language and the array-related Java syntax is very easy and straightforward, for example the n

element of the

array can be obtained as array[n-1]. Collections are more sophisticated and flexible. First of all, they are resizable: you can add any number of

elements to a collection. A collection will automatically handle deletion of an element from any position. There are several types of collections with

different internal storage structure (linear, list, hash set, tree, etc.) and you can choose a collection type best matching your problem so that your most

frequent operations will be convenient and efficient. Collections are Java classes and syntax for obtaining, e.g., the n

element of a collection of

type ArrayList is collection.get(n).

Java arrays and collections

Please note that indexes in Java arrays and collections start with 0, not with 1! In an array or collection of size 10 the index of the first element is

0, and the last element has index 9.

1.8.1. Arrays

Java arrays are containers with linear storage of fixed size. To create an array you should declare a variable of array type and initialize it with a new

array, like this:

int[] intarray = new int[100]; //array of 100 integer numbers

Array type is composed of the element type followed by square brackets, e.g. int[], double[], String[], Agent[]. The size of the array is not a

part of its type. Allocation of the actual storage space (memory) for the array elements is done by the expression new int[100], and this is where

the size is defined. Note that unless you initialize the array with the allocated storage, it will be equal to null, and you will not be able to access its

elements.

A graphical declaration of the same array of 100 integers will look like the Figure. You should use a Variable or Parameter object, choose Other for

Type and enter the array type in the field on the right.

Do not be confused by the checkbox Array in the properties of Parameter: that checkbox sets the type of parameter to System Dynamics

HyperArray and not to Java array.

2022/1/11 上午9:37

Advanced Modeling with Java

127.0.0.1:13091/help/advanced/print.jsp?topic=/../nav/3

17/122

Array variable declared graphically

All elements of the array initialized that way will be set to 0 (for numeric element type), false for boolean type and null for all classes including

String. Another option is to explicitly provide initial values for all array elements. The syntax is the following:

int[] intarray = new int[] { 13, x-3, -15, 0, max{ a, 100 ) };

The size of the array is then defined by the number of expressions in braces. To obtain the size of an existing array you should write <array

name>.length, for example:

intarray.length

The i

element of an array (remember that array indexes are 0-based) can be accessed as:

intarray[i-1]

Iteration over array elements is done by index. The following loop increments each element of the array:

for(int i=0; i<intarray.length; i++) {

intarray[i]++;

}

Java also supports a simpler form of the "for" loop for arrays. The following code calculates the sum of the array elements:

int sum = 0;

for(int element : intarray) {

sum+=element;

}

Arrays can be multidimensional. This piece of code creates a two-dimensional array of double values and initializes it in a loop:

double[][] doubleArray = new double[10][20];

for(int i=0; i<doublearray.length; i++) {

for(int j=0; j<doubleArray[i].length; j++ ) {

doubleArray[i][j] = i * j;

}

You can think of a multidimensional array as "array of arrays". The initialized as new double[10][20] is array of 10 arrays of 20 double values

each. Notice that doublearray.length returns 10 and doubleArray[i].length returns 20.

1.8.2. Collections

Collections are Java classes developed to efficiently store multiple elements of a certain type. Unlike Java arrays collections can store any number of

elements. The simplest collection is ArrayList, which you can treat as a resizable array. The following line of code creates an (initially empty)

ArrayList of objects of class Person:

ArrayList<Person> friends = new ArrayList<Person>();

Note that the type of the collection includes the element type in angle brackets. This "tunes" the collection to work with the specific element type, so

that, for example, the function get() of friends will return object of type Person. The ArrayList<Person> offers the following API (for the

complete API see Java Class Reference):

int size() – returns the number of elements in the list

boolean isEmpty() – tests if this list has no elements

Person get( int index ) – returns the element at the specified position in this list

boolean add( Person p ) – appends the specified element to the end of this list

Person remove( int index ) – removes the element at the specified position in this list

boolean contains( Person p ) – returns true if this list contains a given element

void clear() – removes all of the elements from this list

The following code fragment tests if the friends list contains the person victor and, if, victor is not in there, adds him to the list:

if( ! friends.contains( victor ) )

friends.add( victor );

2022/1/11 上午9:37

Advanced Modeling with Java

127.0.0.1:13091/help/advanced/print.jsp?topic=/../nav/3

18/122

All collection types support iteration over elements. The simplest construct for iteration is a "for" loop. Suppose the class Person has a field income.

The loop below prints all friends with income greater than 100000 to the model log:

for( Person p : friends ) {

if( p.income > 100000 )

traceln( p );

}

Another popular collection type is LinkedList.

Linked lists are used to model stack or queue structures, i.e. sequential storages where elements are primarily added and removed from one or

both ends.

Consider a model of a distributor that maintains a backlog of orders from retailers. Suppose there is an Order class with the amount field. The

backlog (essentially a FIFO queue) can be modeled as:

LinkedList<Order> backlog = new LinkedList<Order>();

LinkedList supports functions common to all collections (like size() or isEmpty()) and also offers a specific API:

Order getFirst() – returns the first element in this list

Order getLast() – returns the last element in this list

addFirst( Order o ) – inserts the given element at the beginning of this list

addLast( Order o ) – appends the given element to the end of this list

Order removeFirst() – removes and returns the first element from this list

Order removeLast() – removes and returns the last element from this list

When a new order is received by the distributor it is placed at the end of the backlog:

backlog.addLast( order );

Each time the inventory gets replenished, the distributor tries to ship the orders starting from the head of the backlog. If the amount in an order is

bigger than the remaining inventory, the order processing stops. The order processing can look like this:

while( ! backlog.isEmpty() ) { //repeat the code below while the backlog is not empty

Order order = backlog.getFirst(); //pick the first order in the backlog

if( order.amount <= inventory ) { //if enough inventory to satisfy this order

ship( order ); //ship

inventory -= order.amount; //decrease available inventory

backlog.removeFirst(); //remove the order from the backlog

} else { //not enough inventory to ship

break; //stop order backlog processing

}

We recommend to declare collections in agents and experiments graphically. The Collection object is located in the Agent palette. All you need to do

is to drop it on the canvas and choose the collection and the element types. At runtime you will be able to view the collection contents by clicking its

icon.

Declaring Java collection graphically

Different types of collections have different time complexity of operations. For example, checking if a collection of 10,000,000 objects contains a given

object may take 80 milliseconds for ArrayList, 100 milliseconds for LinkedList, and less than 1 millisecond for HashSet and TreeSet. To

ensure maximum efficiency of the model execution you should analyze, which operations are most frequent and choose the collection type

correspondingly. The Table below contains the time complexities of the most common operations for four collection types.

Operation

ArrayList LinkedList HashSet TreeSet

Obtain size Constant Constant Constant Constant

Add element Constant Constant Constant Log

2022/1/11 上午9:37

Advanced Modeling with Java

127.0.0.1:13091/help/advanced/print.jsp?topic=/../nav/3

19/122

Remove given element Linear Linear Constant Log

Remove by index Linear Linear – –

Get element by index Constant Linear – –

Find out if contains Linear Linear Constant Log

The terms constant, linear, and logarithmic complexity mean the following. Linear complexity means that the worst time required to complete the

operation grows linearly as the size of the collection grows. Constant means that it does not depend on the size at all, and Log means the time grows

as the logarithm of the size. You should not treat the constant complexity as the unconditionally best choice. Depending on the size, different types of

collection may behave better than others.

Consider the Figure. It may well happen that with relatively small number of elements the collection with linear complexity will behave better than the

one with constant complexity.

Depending on the size, different types of collections may behave better that others

And a couple of things you should keep in mind when choosing the collection type:

HashSet and TreeSet do not support element indexes, so it is not possible to e.g. get an element at position 32.

TreeSet is a naturally sorted collection: elements are stored in a certain order defined by a natural or a user-provided comparator.

Agent populations are collections too

When you declare a nested agent as replicated, AnyLogic creates a special type of collection to store the individual agents. You have two options:

AgentArrayList – choose this collection type if the set of agents is more or less constant or if you need to frequently access individual

agents by index.

AgentLinkedHashSet – choose this option if you plan to intensively add new agents and remove existing ones. For example, if you are

modeling a population of a city for a relatively long period so that people are born, die, move out of the city, and new people arrive.

The options for the type of collection appear in the Advanced section of the nested agent properties, see the Figure.

Options for collection type of a replicated object

Both collections support functions like size(), isEmpty(), get( int index ), contains( Object ao ), and iteration. If index is not

specifically needed during iteration, it is always better to use the enhanced form of "for" loop:

for( Person p : people ) {

…

}

1.9. Comments

2022/1/11 上午9:37

Advanced Modeling with Java

127.0.0.1:13091/help/advanced/print.jsp?topic=/../nav/3

20/122

Comments in Java are used to provide additional information about the code that may not be clear from the code itself. Even if you do not expect

other people to read and try to understand your code, you should write comments for yourself, so that when you come back to your model in a couple

of months you will be able to easily remember how it works, fix, or update it. Comments keep your code live and maintainable; writing good

comments as you write code must become your habit.

This is an example of a useless comment:

client = null; //set client to null – useless comment

It explains things obvious from the code. Instead, you can explain the meaning of the assignment:

client = null; //forget the client – all operations are finished

In Java there are two types of comments: end of line comments and block comments. The end of line comment starts with double slash // and tells

java to treat the text from there to the end of the current line as comment:

//create a new plant

Plant plant = add_mills();

//place it somewhere in the selected region

double[] loc = region.findLocation();

plant.setXY( loc[0], loc[1] );

//set the plant parameters

plant.set_region( region );

plant.set_company( this ); //we are the owner

AnyLogic Java editor displays the comments in green color, so you can easily distinguish them from code. Block comment is delimited by /* and */.

Unlike the end of line comment, the block comment can be placed in the middle of a line (even in the middle of an expression), or it can span across

several lines.

/* for sales staff we include also the commission part

* that is based on the sales this quarter

amount = employee.baseSalary commissionRate * employee.sales bonus;

if( amount > 200000 )

doAudit( employee ); /* perform audit for very high payments */

employee.pay( amount );

When you are developing a model it may be needed to temporarily exclude portions of code from compilation, for example, for debugging purposes.

This is naturally done by using comments. In the expression below the commission part of the salary is temporary excluded from the expression, for

example, until the commissions get modeled.

amount = employee.baseSalary /* commissionRate * employee.sales */ bonus;

If you wish to exclude one or a couple of lines of code, it makes sense to put the end of line comments at the beginning of the line(s). In the code

fragment below the line with the function call ship() will be ignored by the compiler (note that the line already contains a comment):

while( ! backlog.isEmpty() ) { //repeat the code below while the backlog is not empty

Order order = backlog.getFirst(); //pick the first order in the backlog

if( order.amount <= inventory ) { //if enough inventory to satisfy this order

// ship( order ); //ship

inventory -= order.amount; //decrease available inventory

backlog.removeFirst(); //remove the order from the backlog

} else { //not enough inventory to ship

break; //stop order backlog processing

}

If many lines are excluded, it is better to use block comments:

while( ! backlog.isEmpty() ) { //repeat the code below while the backlog is not empty

Order order = backlog.getFirst(); //pick the first order in the backlog

if( order.amount <= inventory ) { //if enough inventory to satisfy this order

// ship( order ); //ship

inventory -= order.amount; //decrease available inventory

backlog.removeFirst(); //remove the order from the backlog

} else { //not enough inventory to ship

break; //stop order backlog processing

}

Be careful when using comments to exclude code: you may make undesirable changes to the code nearby . Consider the code fragment below. The

original plan was to perform audit for every payment that is over $200,000. The model developer decided to temporary skip the audit and commented

out the line with the doAudit() function call. As a side effect, the next line became a part of the if statement and the payments will be made only to

those employees who earn more than $200,000.

amount = employee.baseSalary commissionRate * employee.sales bonus;

if( amount > 200000 )

// doAudit( employee );

employee.pay( amount );

Note that the accident could have been avoided if the modeler had used the block braces with the if statement:

amount = employee.baseSalary commissionRate * employee.sales bonus;

if( amount > 200000 ) {

// doAudit( employee );

}

employee.pay( amount );

剩余121页未读，继续阅读

gw_dragon

粉丝: 128
资源: 2

Java基础与高级建模指南

Addison.Wesley.C++.by.Dissection.2002.pdf

Elasticsearch.Essentials.1784391018.pdf

java 数据挖掘，pdf，2006

Mastering Java Machine Learning

Mastering Java for Data Science

Mobile Applications Development with Android: Technologies and Algorithms

(175797816)华南理工大学信号与系统Signal and Systems期末考试试卷及答案

深圳建设施工项目安全生产奖惩管理制度.docx

离散数学课后题答案+sdut往年试卷+复习提纲资料

自考04741计算机网络原理真题及答案及课件

最新资源