Класс integer в java

Пункт 1: старайтесь давать осмысленные имена локальным переменным

Обычно мы фокусируемся на том, чтобы давать правильные имена полям классов, но мы не уделяем такого же внимания именам локальных переменных


Когда наши методы отлично реализованы, содержат мало кода и имеют хорошие имена, то очень часто мы не обращаем внимание на локальные переменные, а то и вовсе сокращаем их имена

Когда мы используем var вместо написания явных типов, то компилятор определяет их автоматически и подставляет вместо var. Но с другой стороны в результате этого людям становится труднее читать и понимать код, так как использование var может усложнить его читаемость и понимание. В большинстве случаев это происходит потому, что мы склонны смотреть на тип переменной, как на первичную информацию, а на ее имя, как на вторичную. Хотя должно быть как раз наоборот.

Пример 1:

Наверно, многие согласятся, что в примере ниже имена локальных переменных слишком короткие:

При использовании коротких имен, совместно с var, код становится еще менее понятным:

Более предпочтительный вариант:

Избегайте подобного именования переменных:

Используйте более осмысленные имена:

Пример 3:

В стремлении давать более понятные имена локальным переменным, не впадайте в крайности:

Вместо этого можно использовать более краткий, но не менее понятный вариант:

Знаете ли вы, что у Java есть внутренний класс с именем:InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState

Что же, именование переменных с таким типом может быть непростым делом 🙂

Default Values

It’s not always necessary to assign a value when a field is declared. Fields that are declared but not initialized will be set to a reasonable default by the compiler. Generally speaking, this default will be zero or , depending on the data type. Relying on such default values, however, is generally considered bad programming style.

The following chart summarizes the default values for the above data types.

Data Type Default Value (for fields)
byte
short
int
long 0L
float 0.0f
double 0.0d
char ‘\u0000’
String (or any object)   null
boolean false

Local variables are slightly different; the compiler never assigns a default value to an uninitialized local variable. If you cannot initialize your local variable where it is declared, make sure to assign it a value before you attempt to use it. Accessing an uninitialized local variable will result in a compile-time error.

Literals

You may have noticed that the keyword isn’t used when initializing a variable of a primitive type. Primitive types are special data types built into the language; they are not objects created from a class. A literal is the source code representation of a fixed value; literals are represented directly in your code without requiring computation. As shown below, it’s possible to assign a literal to a variable of a primitive type:

boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;

Integer Literals

An integer literal is of type if it ends with the letter or ; otherwise it is of type . It is recommended that you use the upper case letter because the lower case letter is hard to distinguish from the digit .

Values of the integral types , , , and can be created from literals. Values of type that exceed the range of can be created from literals. Integer literals can be expressed by these number systems:

  • Decimal: Base 10, whose digits consists of the numbers 0 through 9; this is the number system you use every day
  • Hexadecimal: Base 16, whose digits consist of the numbers 0 through 9 and the letters A through F
  • Binary: Base 2, whose digits consists of the numbers 0 and 1 (you can create binary literals in Java SE 7 and later)

For general-purpose programming, the decimal system is likely to be the only number system you’ll ever use. However, if you need to use another number system, the following example shows the correct syntax. The prefix indicates hexadecimal and indicates binary:

// The number 26, in decimal
int decVal = 26;
//  The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;

Floating-Point Literals

A floating-point literal is of type if it ends with the letter or ; otherwise its type is and it can optionally end with the letter or .

The floating point types ( and ) can also be expressed using E or e (for scientific notation), F or f (32-bit float literal) and D or d (64-bit double literal; this is the default and by convention is omitted).

double d1 = 123.4;
// same value as d1, but in scientific notation
double d2 = 1.234e2;
float f1  = 123.4f;

Character and String Literals

Literals of types and may contain any Unicode (UTF-16) characters. If your editor and file system allow it, you can use such characters directly in your code. If not, you can use a «Unicode escape» such as (capital C with circumflex), or (Sí Señor in Spanish). Always use ‘single quotes’ for literals and «double quotes» for literals. Unicode escape sequences may be used elsewhere in a program (such as in field names, for example), not just in or literals.

The Java programming language also supports a few special escape sequences for and literals: (backspace), (tab), (line feed), (form feed), (carriage return), (double quote), (single quote), and (backslash).

There’s also a special literal that can be used as a value for any reference type. may be assigned to any variable, except variables of primitive types. There’s little you can do with a value beyond testing for its presence. Therefore, is often used in programs as a marker to indicate that some object is unavailable.

Finally, there’s also a special kind of literal called a class literal, formed by taking a type name and appending «; for example, . This refers to the object (of type ) that represents the type itself.

Library Macros

The following values are implementation-specific and defined with the #define directive, but these values may not be any lower than what is given here.

Macro Value Description
CHAR_BIT 8 Defines the number of bits in a byte.
SCHAR_MIN -128 Defines the minimum value for a signed char.
SCHAR_MAX +127 Defines the maximum value for a signed char.
UCHAR_MAX 255 Defines the maximum value for an unsigned char.
CHAR_MIN -128 Defines the minimum value for type char and its value will be equal to SCHAR_MIN if char represents negative values, otherwise zero.
CHAR_MAX +127 Defines the value for type char and its value will be equal to SCHAR_MAX if char represents negative values, otherwise UCHAR_MAX.
MB_LEN_MAX 16 Defines the maximum number of bytes in a multi-byte character.
SHRT_MIN -32768 Defines the minimum value for a short int.
SHRT_MAX +32767 Defines the maximum value for a short int.
USHRT_MAX 65535 Defines the maximum value for an unsigned short int.
INT_MIN -2147483648 Defines the minimum value for an int.
INT_MAX +2147483647 Defines the maximum value for an int.
UINT_MAX 4294967295 Defines the maximum value for an unsigned int.
LONG_MIN -9223372036854775808 Defines the minimum value for a long int.
LONG_MAX +9223372036854775807 Defines the maximum value for a long int.
ULONG_MAX 18446744073709551615 Defines the maximum value for an unsigned long int.

8 ответов

27 Лучший ответ


Потому что целое число переполняется. Когда он переполняется, следующее значение .

22 фев. 2012, в 15:33 Поделиться 20

Целочисленное хранилище переполняется и :

Пример в 4-разрядном хранилище:

MAX_INT + 1:

22 фев. 2012, в 16:09 Поделиться 9

Я считаю, что эта ссылка объясняет, что вы видите: http://en.wikipedia.org/wiki/Two’s_complement

22 фев. 2012, в 17:06 Поделиться 8

Вы должны понимать, как целочисленные значения представлены в двоичной форме и как работает двоичное сложение. Java использует представление, называемое двумя дополнениями, в котором первый бит числа представляет собой его знак. Всякий раз, когда вы добавляете 1 к самому большому java Integer, который имеет битовый знак 0, тогда его битовый знак становится 1, а число становится отрицательным.

Эти ссылки объясняются с более подробной информацией:

Спецификация языка Java рассматривает это поведение здесь:

Это означает, что вы можете положиться на это поведение.

22 фев. 2012, в 16:47 Поделиться 4


По той же причине, почему дата меняется при пересечении международной линии дат: там есть разрыв. Он встроен в природу двоичного добавления.

22 фев. 2012, в 16:03 Поделиться 4

Это хорошо известная проблема, связанная с тем, что целые числа представлены как два дополнения вниз на двоичном уровне, Когда вы добавляете 1 к максимальному значению двух дополнительных номеров, вы получаете минимальное значение. Честно говоря, все целые числа вели себя таким образом до того, как существовал Java, и изменение этого поведения для языка Java добавило бы дополнительные накладные расходы для целочисленной математики и запутанных программистов, поступающих с других языков.

22 фев. 2012, в 15:27 Поделиться 3

В большинстве процессоров арифметические команды не имеют режима для отказа при переполнении. Они устанавливают флаг, который необходимо проверить. Это дополнительная инструкция, поэтому, вероятно, медленнее. Для того чтобы языковые реализации были как можно быстрее, языки часто указываются для игнорирования ошибки и продолжения. Для Java поведение указано в JLS. Для C язык не определяет поведение, но современные процессоры будут вести себя как Java.

Я считаю, что есть предложения для (неудобных) библиотек Java SE 8 для переполнения, а также для неподписанных операций. Поведение, которое я считаю популярным в мире DSP, — это зажать значения в максимумах, поэтому .

Я уверен, что будущие языки будут использовать произвольные прецизионные ints, но не на какое-то время. Требуется более дорогая компоновка компилятора для быстрого запуска.

22 фев. 2012, в 16:36 Поделиться 3

Когда вы добавляете (в двоичном формате ) в 1 (в двоичном формате ), вы должны изменить на (в двоичном ) все двоичные , начиная с правой, пока вы не получите 0, который вы должны изменить на . имеет все места, заполненные , поэтому остается только s.

22 фев. 2012, в 15:25 Поделиться

Ещё вопросы

  • 159com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: сбой линии связи
  • 38Как связать SQLite с Java?
  • 2845Как генерировать случайные целые числа в определенном диапазоне в Java?
  • 2987Итерация по HashMap
  • 1814Как мне объявить и инициализировать массив в Java?
  • 1360Как разбить строку в Java
  • 1087Поддерживает ли Java значения параметров по умолчанию?
  • 915Как добавить локальные файлы JAR в проект Maven?
  • 744Ограничение доступа к классу из-за ограничения на требуемую библиотеку rt.jar?
  • 47Зачем использовать целое число вместо длинного?

A Simple Box Class

Begin by examining a non-generic Box class that operates on objects of any type. It needs only to provide two methods: set, which adds an object to the box, and get, which retrieves it:

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

Since its methods accept or return an Object, you are free to pass in whatever you want, provided that it is not one of the primitive types. There is no way to verify, at compile time, how the class is used. One part of the code may place an Integer in the box and expect to get Integers out of it, while another part of the code may mistakenly pass in a String, resulting in a runtime error.

A Generic Version of the Box Class

A generic class is defined with the following format:

class name<T1, T2, ..., Tn> { /* ... */ }

The type parameter section, delimited by angle brackets (<>), follows the class name. It specifies the type parameters (also called type variables) T1, T2, …, and Tn.

To update the Box class to use generics, you create a generic type declaration by changing the code «public class Box» to «public class Box<T>«. This introduces the type variable, T, that can be used anywhere inside the class.

With this change, the Box class becomes:

/**
 * Generic version of the Box class.
 * @param <T> the type of the value being boxed
 */
public class Box<T> {
    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

As you can see, all occurrences of Object are replaced by T. A type variable can be any non-primitive type you specify: any class type, any interface type, any array type, or even another type variable.

This same technique can be applied to create generic interfaces.

Multiple Type Parameters

As mentioned previously, a generic class can have multiple type parameters. For example, the generic OrderedPair class, which implements the generic Pair interface:

public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}

public class OrderedPair<K, V> implements Pair<K, V> {

    private K key;
    private V value;

    public OrderedPair(K key, V value) {
	this.key = key;
	this.value = value;
    }

    public K getKey()	{ return key; }
    public V getValue() { return value; }
}

The following statements create two instantiations of the OrderedPair class:

Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String>  p2 = new OrderedPair<String, String>("hello", "world");

The code, new OrderedPair<String, Integer>, instantiates K as a String and V as an Integer. Therefore, the parameter types of OrderedPair‘s constructor are String and Integer, respectively. Due to autoboxing, it is valid to pass a String and an int to the class.

As mentioned in , because a Java compiler can infer the K and V types from the declaration OrderedPair<String, Integer>, these statements can be shortened using diamond notation:

OrderedPair<String, Integer> p1 = new OrderedPair<>("Even", 8);
OrderedPair<String, String>  p2 = new OrderedPair<>("hello", "world");

To create a generic interface, follow the same conventions as for creating a generic class.

Using Underscore Characters in Numeric Literals

In Java SE 7 and later, any number of underscore characters () can appear anywhere between digits in a numerical literal. This feature enables you, for example. to separate groups of digits in numeric literals, which can improve the readability of your code.

For instance, if your code contains numbers with many digits, you can use an underscore character to separate digits in groups of three, similar to how you would use a punctuation mark like a comma, or a space, as a separator.

The following example shows other ways you can use the underscore in numeric literals:

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi =  3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;

You can place underscores only between digits; you cannot place underscores in the following places:

  • At the beginning or end of a number
  • Adjacent to a decimal point in a floating point literal
  • Prior to an or suffix
  • In positions where a string of digits is expected

The following examples demonstrate valid and invalid underscore placements (which are highlighted) in numeric literals:

// Invalid: cannot put underscores
// adjacent to a decimal point
float pi1 = 3_.1415F;
// Invalid: cannot put underscores 
// adjacent to a decimal point
float pi2 = 3._1415F;
// Invalid: cannot put underscores 
// prior to an L suffix
long socialSecurityNumber1 = 999_99_9999_L;

// OK (decimal literal)
int x1 = 5_2;
// Invalid: cannot put underscores
// At the end of a literal
int x2 = 52_;
// OK (decimal literal)
int x3 = 5_______2;

// Invalid: cannot put underscores
// in the 0x radix prefix
int x4 = 0_x52;
// Invalid: cannot put underscores
// at the beginning of a number
int x5 = 0x_52;
// OK (hexadecimal literal)
int x6 = 0x5_2; 
// Invalid: cannot put underscores
// at the end of a number
int x7 = 0x52_;

С этим читают